@powersync/web 2.1.1 → 2.2.0

package/dist/index.react_native_web.js

@@ -442,6 +442,50 @@ function resolveAndValidateOptions(options) {
     return resolved;
 }
 
+class PreparedStatementCache {
+    #size;
+    // Note that Map preserves insertion order, which allows using it as an LRU
+    // cache (with the first element being the first element to evict).
+    #statements = new Map();
+    constructor(size) {
+        this.#size = size;
+    }
+    /**
+     * Attempts to look up the cached sql statement, if it's currently cached.
+     */
+    lookup(sql) {
+        const foundStatement = this.#statements.get(sql);
+        if (foundStatement != null) {
+            // Delete and re-insert to move to the end (most-recently-used position).
+            this.#statements.delete(sql);
+            this.#statements.set(sql, foundStatement);
+            return foundStatement;
+        }
+        return null;
+    }
+    /**
+     * Adds a new statement into the cache.
+     *
+     * If that exceeds the target size of the statement cache, returns an old statement to evict.
+     * The caller is responsible for freeing that statement.
+     */
+    addStatement(sql, statement) {
+        this.#statements.set(sql, statement);
+        if (this.#statements.size > this.#size) {
+            for (const [k, v] of this.#statements.entries()) {
+                this.#statements.delete(k);
+                return v;
+            }
+        }
+        return null;
+    }
+    drain() {
+        const values = [...this.#statements.values()];
+        this.#statements.clear();
+        return values;
+    }
+}
+
 /**
  * A small wrapper around WA-sqlite to help with opening databases and running statements by preparing them internally.
  *
@@ -451,18 +495,26 @@ function resolveAndValidateOptions(options) {
 class RawSqliteConnection {
     options;
     _sqliteAPI = null;
+    sqlite3_stmt_isexplain;
     /**
      * The `sqlite3*` connection pointer.
      */
     db = 0;
+    statementCache;
     constructor(options) {
         this.options = options;
+        this.statementCache =
+            options.preparedStatementsCache > 0 ? new PreparedStatementCache(options.preparedStatementsCache) : null;
     }
     get isOpen() {
         return this.db != 0;
     }
     async init() {
-        const api = (this._sqliteAPI = await this.openSQLiteAPI());
+        const { module, vfs } = await loadModuleAndVfs(this.options);
+        await this.initWithModule(module, vfs);
+    }
+    async initWithModule(module, vfs) {
+        const api = (this._sqliteAPI = await this.openSQLiteAPI(module, vfs));
         this.db = await api.open_v2(this.options.filename, this.options.readonly ? 1 /* SQLITE_OPEN_READONLY */ : 6 /* SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE */);
         await this.executeRaw(`PRAGMA temp_store = ${this.options.temporaryStorage};`);
         if (this.options.encryptionKey) {
@@ -472,9 +524,9 @@ class RawSqliteConnection {
         await this.executeRaw(`PRAGMA cache_size = -${this.options.cacheSizeKb};`);
         await this.executeRaw(`SELECT powersync_update_hooks('install');`);
     }
-    async openSQLiteAPI() {
-        const { module, vfs } = await loadModuleAndVfs(this.options);
+    async openSQLiteAPI(module, vfs) {
         vfs.mxPathname = maxPathNameLength;
+        this.sqlite3_stmt_isexplain = module.cwrap('sqlite3_stmt_isexplain', 'int', ['int']);
         const sqlite3 = Factory(module);
         sqlite3.vfs_register(vfs, true);
         /**
@@ -542,7 +594,7 @@ class RawSqliteConnection {
     async executeRaw(sql, bindings) {
         const results = [];
         const api = this.requireSqlite();
-        for await (const stmt of api.statements(this.db, sql)) {
+        for await (const stmt of this.cachedStatements(api, sql)) {
             let columns;
             const rs = await this.stepThroughStatement(api, stmt, bindings ?? [], columns);
             columns = rs.columnNames;
@@ -579,10 +631,52 @@ class RawSqliteConnection {
     }
     async close() {
         if (this.isOpen) {
-            await this.requireSqlite().close(this.db);
+            const api = this.requireSqlite();
+            if (this.statementCache) {
+                for (const stmt of this.statementCache.drain()) {
+                    await api.finalize(stmt);
+                }
+            }
+            await api.close(this.db);
             this.db = 0;
         }
     }
+    async *cachedStatements(api, sql) {
+        {
+            const existing = this.statementCache?.lookup(sql);
+            if (existing != null) {
+                yield existing;
+                return;
+            }
+        }
+        const inner = api.statements(this.db, sql, { unscoped: true });
+        const preparedStatements = [];
+        try {
+            for await (const stmt of inner) {
+                preparedStatements.push(stmt);
+                yield stmt;
+            }
+        }
+        finally {
+            // We can only cache statements if the sql text corresponds to a single statement, otherwise it's not clear what
+            // portion of the original sql text to use as a key.
+            if (preparedStatements.length === 1 && this.statementCache) {
+                const stmt = preparedStatements[0];
+                // Don't cache EXPLAIN statements, their result becomes invalid after schema changes.
+                if (this.sqlite3_stmt_isexplain(stmt) == 0) {
+                    const evicted = this.statementCache.addStatement(sql, stmt);
+                    if (evicted != null) {
+                        await api.finalize(evicted);
+                    }
+                    return;
+                }
+            }
+            // We're not caching statements, so finalize them.
+            for (const stmt of preparedStatements) {
+                await api.finalize(stmt);
+            }
+        }
+    }
 }
 
 /**
@@ -712,7 +806,8 @@ const OPEN_DB_LOCK = 'open-wasqlite-db';
  */
 class MultiDatabaseServer {
     logger;
-    activeDatabases = new Map();
+    #activeDatabases = new Map();
+    #localOpenLock = new Mutex();
     constructor(logger) {
         this.logger = logger;
     }
@@ -727,7 +822,7 @@ class MultiDatabaseServer {
     }
     async connectToExisting(name, lockName) {
         return getNavigatorLocks().request(OPEN_DB_LOCK, async () => {
-            const server = this.activeDatabases.get(name);
+            const server = this.#activeDatabases.get(name);
             if (server == null) {
                 throw new Error(`connectToExisting(${name}) failed because the worker doesn't own a database with that name.`);
             }
@@ -741,7 +836,7 @@ class MultiDatabaseServer {
         let server;
         for (let count = 0; count < maxAttempts - 1; count++) {
             try {
-                server = await this.databaseOpenAttempt(logger, options);
+                server = await this.#databaseOpenAttempt(logger, options);
             }
             catch (error) {
                 this.logger.log({
@@ -753,19 +848,20 @@ class MultiDatabaseServer {
             }
         }
         // Final attempt if we haven't been able to open the server - rethrow errors if we still can't open.
-        server ??= await this.databaseOpenAttempt(logger, options);
+        server ??= await this.#databaseOpenAttempt(logger, options);
         return server.connect(lockName);
     }
-    async databaseOpenAttempt(logger, options) {
-        return getNavigatorLocks().request(OPEN_DB_LOCK, async () => {
-            const { filename, readonly, vfs } = options;
-            let server = this.activeDatabases.get(filename);
+    async #databaseOpenAttempt(logger, options) {
+        const { filename, readonly, vfs } = options;
+        // 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$1 || readonly || vfs == WASQLiteVFS.InMemoryVfs);
+        const activeDatabases = this.#activeDatabases;
+        async function openDatabase() {
+            let server = 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$1 || readonly || vfs == WASQLiteVFS.InMemoryVfs);
                 const connection = new RawSqliteConnection(options);
                 const withSafeConcurrency = new ConcurrentSqliteConnection(connection, needsNavigatorLocks);
                 // Initializing the RawSqliteConnection will run some pragmas that might write to the database file, so we want
@@ -781,19 +877,27 @@ class MultiDatabaseServer {
                     throw e;
                 }
                 returnLease();
-                const onClose = () => this.activeDatabases.delete(filename);
+                const onClose = () => activeDatabases.delete(filename);
                 server = new DatabaseServer({
                     inner: withSafeConcurrency,
                     logger,
                     onClose
                 });
-                this.activeDatabases.set(filename, server);
+                activeDatabases.set(filename, server);
             }
             return server;
-        });
+        }
+        if (needsNavigatorLocks) {
+            return getNavigatorLocks().request(OPEN_DB_LOCK, openDatabase);
+        }
+        else {
+            // Even if we don't need navigator locks, this avoids a race between the activeDatabases.get() call, the async
+            // open logic and the final activeDatabases.set() step.
+            return this.#localOpenLock.runExclusive(openDatabase);
+        }
     }
     closeAll() {
-        const existingDatabases = [...this.activeDatabases.values()];
+        const existingDatabases = [...this.#activeDatabases.values()];
         return Promise.all(existingDatabases.map((db) => {
             db.forceClose();
         }));
@@ -1026,6 +1130,66 @@ function generateTabCloseSignal(abort) {
     });
 }
 
+/**
+ * Internal helper function to acquire a connection from a pool that has a designated writer, additional readers, and
+ * also allows dispatching reads to the writer.
+ */
+async function acquireFromPool(writerMutex, writer, readers, callback, options, allowReadOnly) {
+    const abortController = new AbortController();
+    const abortSignal = abortController.signal;
+    let timeout = null;
+    let release;
+    if (options?.timeoutMs) {
+        timeout = setTimeout(() => abortController.abort('requesting database timed out'), options.timeoutMs);
+    }
+    try {
+        if (allowReadOnly) {
+            let connection;
+            // Even if we have a pool of read connections, it's typically very small and we assume that most queries are
+            // reads. So, we want to request any connection from the read pool and the dedicated write connection (which
+            // can also serve reads). We race for the first connection we can obtain this way, and then abort the other
+            // request.
+            [connection, release] = await new Promise((resolve, reject) => {
+                let didComplete = false;
+                function complete() {
+                    didComplete = true;
+                    abortController.abort();
+                }
+                function completeSuccess(connection, returnFn) {
+                    if (didComplete) {
+                        // We're not going to use this connection, so return it immediately.
+                        returnFn();
+                    }
+                    else {
+                        complete();
+                        resolve([connection, returnFn]);
+                    }
+                }
+                function completeError(error) {
+                    // We either have a working connection already, or we've rejected the promise. Either way, we don't need
+                    // to do either thing again.
+                    if (didComplete)
+                        return;
+                    complete();
+                    reject(error);
+                }
+                writerMutex.acquire(abortSignal).then((unlock) => completeSuccess(writer, unlock), completeError);
+                readers?.requestOne(abortSignal).then(({ item, release }) => completeSuccess(item, release), completeError);
+            });
+            return await callback(connection);
+        }
+        else {
+            return await writerMutex.runExclusive(() => callback(writer), abortSignal);
+        }
+    }
+    finally {
+        if (timeout != null) {
+            clearTimeout(timeout);
+        }
+        release?.();
+    }
+}
+
 /**
  * A connection pool implementation delegating to another pool opened asynchronnously.
  */
@@ -1121,61 +1285,9 @@ function readWritePoolState(writer, readers) {
     return {
         writer,
         async withConnection(allowReadOnly, fn, options) {
-            const abortController = new AbortController();
-            const abortSignal = abortController.signal;
-            let timeout = null;
-            let release;
-            if (options?.timeoutMs) {
-                timeout = setTimeout(() => abortController.abort('requesting database timed out'), options.timeoutMs);
-            }
-            try {
-                if (allowReadOnly) {
-                    let connection;
-                    // Even if we have a pool of read connections, it's typically very small and we assume that most queries are
-                    // reads. So, we want to request any connection from the read pool and the dedicated write connection (which
-                    // can also serve reads). We race for the first connection we can obtain this way, and then abort the other
-                    // request.
-                    [connection, release] = await new Promise((resolve, reject) => {
-                        let didComplete = false;
-                        function complete() {
-                            didComplete = true;
-                            abortController.abort();
-                        }
-                        function completeSuccess(connection, returnFn) {
-                            if (didComplete) {
-                                // We're not going to use this connection, so return it immediately.
-                                returnFn();
-                            }
-                            else {
-                                complete();
-                                resolve([connection, returnFn]);
-                            }
-                        }
-                        function completeError(error) {
-                            // We either have a working connection already, or we've rejected the promise. Either way, we don't need
-                            // to do either thing again.
-                            if (didComplete)
-                                return;
-                            complete();
-                            reject(error);
-                        }
-                        writerMutex.acquire(abortSignal).then((unlock) => completeSuccess(writer, unlock), completeError);
-                        readerSemaphore
-                            .requestOne(abortSignal)
-                            .then(({ item, release }) => completeSuccess(item, release), completeError);
-                    });
-                    return await connection.readLock(fn);
-                }
-                else {
-                    return await writerMutex.runExclusive(() => writer.writeLock(fn), abortSignal);
-                }
-            }
-            finally {
-                if (timeout != null) {
-                    clearTimeout(timeout);
-                }
-                release?.();
-            }
+            return acquireFromPool(writerMutex, writer, readerSemaphore, (connection) => {
+                return allowReadOnly ? connection.readLock(fn) : connection.writeLock(fn);
+            }, options, allowReadOnly);
         },
         async close() {
             await writer.close();
@@ -1309,7 +1421,7 @@ class WASQLiteOpenFactory {
         return this.openAdapter();
     }
     async openConnection() {
-        const { enableMultiTabs, useWebWorker, vfs, dbFilename, encryptionKey, temporaryStorage, cacheSizeKb } = this.options;
+        const { enableMultiTabs, useWebWorker, vfs, dbFilename, encryptionKey, temporaryStorage, cacheSizeKb, preparedStatementsCache } = this.options;
         if (!enableMultiTabs) {
             this.logger.log({ level: LogLevels.warn, message: 'Multiple tabs are not enabled in this browser' });
         }
@@ -1323,7 +1435,9 @@ class WASQLiteOpenFactory {
                 vfs,
                 encryptionKey,
                 temporaryStorage,
-                cacheSizeKb
+                cacheSizeKb,
+                // TODO: Enable prepared statement cache by default?
+                preparedStatementsCache: preparedStatementsCache ?? 0
             };
         }
         if (useWebWorker) {
@@ -1372,10 +1486,11 @@ class WASQLiteOpenFactory {
                 // This VFS supports concurrent reads, so we can open additional workers to host read-only connections for
                 // concurrent reads / writes.
                 const additionalReadersCount = this.options.additionalReaders ?? 1;
+                const additionalReaderPromises = [];
                 for (let i = 0; i < additionalReadersCount; i++) {
-                    const reader = await openDatabaseWorker(true);
-                    additionalReaders.push(reader);
+                    additionalReaderPromises.push(openDatabaseWorker(true));
                 }
+                additionalReaders.push(...(await Promise.all(additionalReaderPromises)));
             }
         }
         else {
@@ -1948,27 +2063,32 @@ class WebPowerSyncDatabase extends BasePowerSyncDatabase {
             identifier: this.database.name,
             logger: this.logger
         };
-        switch (true) {
-            case this.resolvedOpenOptions.ssrMode:
-                return new SSRStreamingSyncImplementation();
-            case this.resolvedOpenOptions.enableMultiTabs:
-                if (!this.enableBroadcastLogs) {
-                    const warning = `
+        if (this.resolvedOpenOptions.ssrMode) {
+            return new SSRStreamingSyncImplementation();
+        }
+        else if (this.resolvedOpenOptions.enableMultiTabs) {
+            if (!this.enableBroadcastLogs) {
+                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
           `;
-                    const logger = this.options.logger;
-                    logger ? logger.log({ level: LogLevels.warn, message: warning }) : console.warn(warning);
-                }
+                const logger = this.options.logger;
+                logger ? logger.log({ level: LogLevels.warn, message: warning }) : console.warn(warning);
+            }
+            if ('shareConnection' in this.database) {
                 return new SharedWebStreamingSyncImplementation({
                     ...syncOptions,
                     db: this.database, // This should always be the case
                     logLevel: this.options.sync?.logLevel ?? LogLevels.info,
                     enableBroadcastLogs: this.enableBroadcastLogs
                 });
-            default:
-                return new TabLocalStreamingSyncImplementation(syncOptions);
+            }
+            this.logger.log({
+                level: LogLevels.warn,
+                message: "Not using a shared sync worker because the database adapter doesn't support it."
+            });
         }
+        return new TabLocalStreamingSyncImplementation(syncOptions);
     }
 }
 /**