Merge branch 'main' into sync-progress

Author: simolus3

packages/attachments/package.json

@@ -29,7 +29,7 @@
     "test": "pnpm build && vitest"
   },
   "peerDependencies": {
-    "@powersync/common": "workspace:^1.27.0"
+    "@powersync/common": "workspace:^1.27.1"
   },
   "devDependencies": {
     "@powersync/common": "workspace:*",

packages/common/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @powersync/common
 
+## 1.27.1
+
+### Patch Changes
+
+- 720ad7a: Fix a race condition causing sync changes during uploads not to be applied.
+
 ## 1.27.0
 
 ### Minor Changes

packages/common/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@powersync/common",
-  "version": "1.27.0",
+  "version": "1.27.1",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"

packages/common/src/client/AbstractPowerSyncDatabase.ts

@@ -15,7 +15,7 @@ import { Schema } from '../db/schema/Schema.js';
 import { BaseObserver } from '../utils/BaseObserver.js';
 import { ControlledExecutor } from '../utils/ControlledExecutor.js';
 import { mutexRunExclusive } from '../utils/mutex.js';
-import { throttleTrailing } from '../utils/throttle.js';
+import { throttleTrailing } from '../utils/async.js';
 import { SQLOpenFactory, SQLOpenOptions, isDBAdapter, isSQLOpenFactory, isSQLOpenOptions } from './SQLOpenFactory.js';
 import { PowerSyncBackendConnector } from './connection/PowerSyncBackendConnector.js';
 import { runOnSchemaChange } from './runOnSchemaChange.js';
@@ -263,7 +263,7 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
   /**
    * Wait for the first sync operation to complete.
    *
-   * @argument request Either an abort signal (after which the promise will complete regardless of
+   * @param request Either an abort signal (after which the promise will complete regardless of
    * whether a full sync was completed) or an object providing an abort signal and a priority target.
    * When a priority target is set, the promise may complete when all buckets with the given (or higher)
    * priorities have been synchronized. This can be earlier than a complete sync.
@@ -536,7 +536,7 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
   }
 
   /**
-   * Get a batch of crud data to upload.
+   * Get a batch of CRUD data to upload.
    *
    * Returns null if there is no data to upload.
    *
@@ -551,6 +551,9 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
    * This method does include transaction ids in the result, but does not group
    * data by transaction. One batch may contain data from multiple transactions,
    * and a single transaction may be split over multiple batches.
+   * 
+   * @param limit Maximum number of CRUD entries to include in the batch
+   * @returns A batch of CRUD operations to upload, or null if there are none
    */
   async getCrudBatch(limit: number = DEFAULT_CRUD_BATCH_LIMIT): Promise<CrudBatch | null> {
     const result = await this.getAll<CrudEntryJSON>(
@@ -587,6 +590,8 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
    *
    * Unlike {@link getCrudBatch}, this only returns data from a single transaction at a time.
    * All data for the transaction is loaded into memory.
+   * 
+   * @returns A transaction of CRUD operations to upload, or null if there are none
    */
   async getNextCrudTransaction(): Promise<CrudTransaction | null> {
     return await this.readTransaction(async (tx) => {
@@ -624,6 +629,8 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
    * Get an unique client id for this database.
    *
    * The id is not reset when the database is cleared, only when the database is deleted.
+   * 
+   * @returns A unique identifier for the database instance
    */
   async getClientId(): Promise<string> {
     return this.bucketStorageAdapter.getClientId();
@@ -648,14 +655,27 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
   }
 
   /**
-   * Execute a write (INSERT/UPDATE/DELETE) query
+   * Execute a SQL write (INSERT/UPDATE/DELETE) query
    * and optionally return results.
+   * 
+   * @param sql The SQL query to execute
+   * @param parameters Optional array of parameters to bind to the query
+   * @returns The query result as an object with structured key-value pairs
    */
   async execute(sql: string, parameters?: any[]) {
     await this.waitForReady();
     return this.database.execute(sql, parameters);
   }
 
+  /**
+   * Execute a SQL write (INSERT/UPDATE/DELETE) query directly on the database without any PowerSync processing.
+   * This bypasses certain PowerSync abstractions and is useful for accessing the raw database results.
+   * 
+   * @param sql The SQL query to execute
+   * @param parameters Optional array of parameters to bind to the query
+   * @returns The raw query result from the underlying database as a nested array of raw values, where each row is
+   * represented as an array of column values without field names.
+   */
   async executeRaw(sql: string, parameters?: any[]) {
     await this.waitForReady();
     return this.database.executeRaw(sql, parameters);
@@ -665,6 +685,10 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
    * Execute a write query (INSERT/UPDATE/DELETE) multiple times with each parameter set
    * and optionally return results.
    * This is faster than executing separately with each parameter set.
+   * 
+   * @param sql The SQL query to execute
+   * @param parameters Optional 2D array of parameter sets, where each inner array is a set of parameters for one execution
+   * @returns The query result
    */
   async executeBatch(sql: string, parameters?: any[][]) {
     await this.waitForReady();
@@ -673,6 +697,10 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
 
   /**
    *  Execute a read-only query and return results.
+   * 
+   * @param sql The SQL query to execute
+   * @param parameters Optional array of parameters to bind to the query
+   * @returns An array of results
    */
   async getAll<T>(sql: string, parameters?: any[]): Promise<T[]> {
     await this.waitForReady();
@@ -681,6 +709,10 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
 
   /**
    * Execute a read-only query and return the first result, or null if the ResultSet is empty.
+   * 
+   * @param sql The SQL query to execute
+   * @param parameters Optional array of parameters to bind to the query
+   * @returns The first result if found, or null if no results are returned
    */
   async getOptional<T>(sql: string, parameters?: any[]): Promise<T | null> {
     await this.waitForReady();
@@ -689,6 +721,11 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
 
   /**
    * Execute a read-only query and return the first result, error if the ResultSet is empty.
+   * 
+   * @param sql The SQL query to execute
+   * @param parameters Optional array of parameters to bind to the query
+   * @returns The first result matching the query
+   * @throws Error if no rows are returned
    */
   async get<T>(sql: string, parameters?: any[]): Promise<T> {
     await this.waitForReady();
@@ -720,6 +757,11 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
    * Open a read-only transaction.
    * Read transactions can run concurrently to a write transaction.
    * Changes from any write transaction are not visible to read transactions started before it.
+   * 
+   * @param callback Function to execute within the transaction
+   * @param lockTimeout Time in milliseconds to wait for a lock before throwing an error
+   * @returns The result of the callback
+   * @throws Error if the lock cannot be obtained within the timeout period
    */
   async readTransaction<T>(
     callback: (tx: Transaction) => Promise<T>,
@@ -740,6 +782,11 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
    * Open a read-write transaction.
    * This takes a global lock - only one write transaction can execute against the database at a time.
    * Statements within the transaction must be done on the provided {@link Transaction} interface.
+   * 
+   * @param callback Function to execute within the transaction
+   * @param lockTimeout Time in milliseconds to wait for a lock before throwing an error
+   * @returns The result of the callback
+   * @throws Error if the lock cannot be obtained within the timeout period
    */
   async writeTransaction<T>(
     callback: (tx: Transaction) => Promise<T>,
@@ -814,6 +861,11 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
    * Source tables are automatically detected using `EXPLAIN QUERY PLAN`.
    *
    * Note that the `onChange` callback member of the handler is required.
+   * 
+   * @param sql The SQL query to execute
+   * @param parameters Optional array of parameters to bind to the query
+   * @param handler Callbacks for handling results and errors
+   * @param options Options for configuring watch behavior
    */
   watchWithCallback(sql: string, parameters?: any[], handler?: WatchHandler, options?: SQLWatchOptions): void {
     const { onResult, onError = (e: Error) => this.options.logger?.error(e) } = handler ?? {};
@@ -859,6 +911,11 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
    * Execute a read query every time the source tables are modified.
    * Use {@link SQLWatchOptions.throttleMs} to specify the minimum interval between queries.
    * Source tables are automatically detected using `EXPLAIN QUERY PLAN`.
+   * 
+   * @param sql The SQL query to execute
+   * @param parameters Optional array of parameters to bind to the query
+   * @param options Options for configuring watch behavior
+   * @returns An AsyncIterable that yields QueryResults whenever the data changes
    */
   watchWithAsyncGenerator(sql: string, parameters?: any[], options?: SQLWatchOptions): AsyncIterable<QueryResult> {
     return new EventIterator<QueryResult>((eventOptions) => {
@@ -879,6 +936,16 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
     });
   }
 
+  /**
+   * Resolves the list of tables that are used in a SQL query.
+   * If tables are specified in the options, those are used directly.
+   * Otherwise, analyzes the query using EXPLAIN to determine which tables are accessed.
+   * 
+   * @param sql The SQL query to analyze
+   * @param parameters Optional parameters for the SQL query
+   * @param options Optional watch options that may contain explicit table list
+   * @returns Array of table names that the query depends on
+   */
   async resolveTables(sql: string, parameters?: any[], options?: SQLWatchOptions): Promise<string[]> {
     const resolvedTables = options?.tables ? [...options.tables] : [];
     if (!options?.tables) {
@@ -951,7 +1018,9 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
    *
    * Note that the `onChange` callback member of the handler is required.
    *
-   * Returns dispose function to stop watching.
+   * @param handler Callbacks for handling change events and errors
+   * @param options Options for configuring watch behavior
+   * @returns A dispose function to stop watching for changes
    */
   onChangeWithCallback(handler?: WatchOnChangeHandler, options?: SQLWatchOptions): () => void {
     const { onChange, onError = (e: Error) => this.options.logger?.error(e) } = handler ?? {};
@@ -1004,8 +1073,11 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
    *
    * This is preferred over {@link watchWithAsyncGenerator} when multiple queries need to be performed
    * together when data is changed.
+   * 
+   * Note: do not declare this as `async *onChange` as it will not work in React Native.
    *
-   * Note, do not declare this as `async *onChange` as it will not work in React Native
+   * @param options Options for configuring watch behavior
+   * @returns An AsyncIterable that yields change events whenever the specified tables change
    */
   onChangeWithAsyncGenerator(options?: SQLWatchOptions): AsyncIterable<WatchOnChangeEvent> {
     const resolvedOptions = options ?? {};