@tanstack/powersync-db-collection 0.1.65 → 0.1.67

package/dist/cjs/PowerSyncTransactor.cjs

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const common = require("@powersync/common");
+const db = require("@tanstack/db");
 const DebugModule = require("debug");
 const PendingOperationStore = require("./PendingOperationStore.cjs");
 const helpers = require("./helpers.cjs");
@@ -35,7 +36,21 @@ class PowerSyncTransactor {
         if (collection.isReady()) {
           return;
         }
-        await new Promise((resolve) => collection.onFirstReady(resolve));
+        await new Promise((resolve, reject) => {
+          const check = () => {
+            if (collection.isReady()) {
+              unsubscribe();
+              resolve();
+            } else if (collection.status === `error` || collection.status === `cleaned-up`) {
+              unsubscribe();
+              reject(
+                collection.status === `error` ? collection._lifecycle.getSyncError() ?? new Error(`Collection failed before readiness`) : new db.LoadSubsetOperationAbortedError()
+              );
+            }
+          };
+          const unsubscribe = collection.on(`status:change`, check);
+          check();
+        });
       })
     );
     const { whenComplete } = await this.database.writeTransaction(

package/dist/cjs/PowerSyncTransactor.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"PowerSyncTransactor.cjs","sources":["../../src/PowerSyncTransactor.ts"],"sourcesContent":["import { sanitizeSQL } from '@powersync/common'\nimport DebugModule from 'debug'\nimport { PendingOperationStore } from './PendingOperationStore'\nimport { asPowerSyncRecord, mapOperationToPowerSync } from './helpers'\nimport type { AbstractPowerSyncDatabase, LockContext } from '@powersync/common'\nimport type { PendingMutation, Transaction } from '@tanstack/db'\nimport type { PendingOperation } from './PendingOperationStore'\nimport type {\n  EnhancedPowerSyncCollectionConfig,\n  PowerSyncCollectionMeta,\n} from './definitions'\n\nconst debug = DebugModule.debug(`ts/db:powersync`)\n\nexport type TransactorOptions = {\n  database: AbstractPowerSyncDatabase\n}\n\n/**\n * Applies mutations to the PowerSync database. This method is called automatically by the collection's\n * insert, update, and delete operations. You typically don't need to call this directly unless you\n * have special transaction requirements.\n *\n * @example\n * ```typescript\n * // Create a collection\n * const collection = createCollection(\n *   powerSyncCollectionOptions<Document>({\n *     database: db,\n *     table: APP_SCHEMA.props.documents,\n *   })\n * )\n *\n * const addTx = createTransaction({\n *   autoCommit: false,\n *   mutationFn: async ({ transaction }) => {\n *     await new PowerSyncTransactor({ database: db }).applyTransaction(transaction)\n *   },\n * })\n *\n * addTx.mutate(() => {\n *   for (let i = 0; i < 5; i++) {\n *     collection.insert({ id: randomUUID(), name: `tx-${i}` })\n *   }\n * })\n *\n * await addTx.commit()\n * await addTx.isPersisted.promise\n * ```\n *\n * @param transaction - The transaction containing mutations to apply\n * @returns A promise that resolves when the mutations have been persisted to PowerSync\n */\nexport class PowerSyncTransactor {\n  database: AbstractPowerSyncDatabase\n  pendingOperationStore: PendingOperationStore\n\n  constructor(options: TransactorOptions) {\n    this.database = options.database\n    this.pendingOperationStore = PendingOperationStore.GLOBAL\n  }\n\n  /**\n   * Persists a {@link Transaction} to the PowerSync SQLite database.\n   */\n  async applyTransaction(transaction: Transaction<any>) {\n    const { mutations } = transaction\n\n    if (mutations.length == 0) {\n      return\n    }\n    /**\n     * The transaction might contain operations for different collections.\n     * We can do some optimizations for single-collection transactions.\n     */\n    const mutationsCollectionIds = mutations.map(\n      (mutation) => mutation.collection.id,\n    )\n    const collectionIds = Array.from(new Set(mutationsCollectionIds))\n    const lastCollectionMutationIndexes = new Map<string, number>()\n    const allCollections = collectionIds\n      .map((id) => mutations.find((mutation) => mutation.collection.id == id)!)\n      .map((mutation) => mutation.collection)\n    for (const collectionId of collectionIds) {\n      lastCollectionMutationIndexes.set(\n        collectionId,\n        mutationsCollectionIds.lastIndexOf(collectionId),\n      )\n    }\n\n    // Check all the observers are ready before taking a lock\n    await Promise.all(\n      allCollections.map(async (collection) => {\n        if (collection.isReady()) {\n          return\n        }\n        await new Promise<void>((resolve) => collection.onFirstReady(resolve))\n      }),\n    )\n\n    // Persist to PowerSync\n    const { whenComplete } = await this.database.writeTransaction(\n      async (tx) => {\n        const pendingOperations: Array<PendingOperation | null> = []\n\n        for (const [index, mutation] of mutations.entries()) {\n          /**\n           * Each collection processes events independently. We need to make sure the\n           * last operation for each collection has been observed.\n           */\n          const shouldWait =\n            index == lastCollectionMutationIndexes.get(mutation.collection.id)\n          switch (mutation.type) {\n            case `insert`:\n              pendingOperations.push(\n                await this.handleInsert(mutation, tx, shouldWait),\n              )\n              break\n            case `update`:\n              pendingOperations.push(\n                await this.handleUpdate(mutation, tx, shouldWait),\n              )\n              break\n            case `delete`:\n              pendingOperations.push(\n                await this.handleDelete(mutation, tx, shouldWait),\n              )\n              break\n          }\n        }\n\n        /**\n         * Return a promise from the writeTransaction, without awaiting it.\n         * This promise will resolve once the entire transaction has been\n         * observed via the diff triggers.\n         * We return without awaiting in order to free the write lock.\n         */\n        return {\n          whenComplete: Promise.all(\n            pendingOperations\n              .filter((op) => !!op)\n              .map((op) => this.pendingOperationStore.waitFor(op)),\n          ),\n        }\n      },\n    )\n\n    // Wait for the change to be observed via the diff trigger\n    await whenComplete\n  }\n\n  protected async handleInsert(\n    mutation: PendingMutation<any>,\n    context: LockContext,\n    waitForCompletion: boolean = false,\n  ): Promise<PendingOperation | null> {\n    debug(`insert`, mutation)\n\n    return this.handleOperationWithCompletion(\n      mutation,\n      context,\n      waitForCompletion,\n      // eslint-disable-next-line no-shadow\n      async (tableName, mutation, serializeValue) => {\n        const values = serializeValue(mutation.modified)\n        const keys = Object.keys(values).map((key) => sanitizeSQL`${key}`)\n        const queryParameters = Object.values(values)\n\n        const metadataValue = this.processMutationMetadata(mutation)\n        if (metadataValue != null) {\n          keys.push(`_metadata`)\n          queryParameters.push(metadataValue)\n        }\n\n        await context.execute(\n          `\n        INSERT into ${tableName}\n            (${keys.join(`, `)})\n        VALUES\n            (${keys.map((_) => `?`).join(`, `)})\n        `,\n          queryParameters,\n        )\n      },\n    )\n  }\n\n  protected async handleUpdate(\n    mutation: PendingMutation<any>,\n    context: LockContext,\n    waitForCompletion: boolean = false,\n  ): Promise<PendingOperation | null> {\n    debug(`update`, mutation)\n\n    return this.handleOperationWithCompletion(\n      mutation,\n      context,\n      waitForCompletion,\n      // eslint-disable-next-line no-shadow\n      async (tableName, mutation, serializeValue) => {\n        const values = serializeValue(mutation.modified)\n        const keys = Object.keys(values).map((key) => sanitizeSQL`${key}`)\n        const queryParameters = Object.values(values)\n\n        const metadataValue = this.processMutationMetadata(mutation)\n        if (metadataValue != null) {\n          keys.push(`_metadata`)\n          queryParameters.push(metadataValue)\n        }\n\n        await context.execute(\n          `\n        UPDATE ${tableName}\n        SET ${keys.map((key) => `${key} = ?`).join(`, `)}\n        WHERE id = ?\n        `,\n          [...queryParameters, asPowerSyncRecord(mutation.modified).id],\n        )\n      },\n    )\n  }\n\n  protected async handleDelete(\n    mutation: PendingMutation<any>,\n    context: LockContext,\n    waitForCompletion: boolean = false,\n  ): Promise<PendingOperation | null> {\n    debug(`update`, mutation)\n\n    return this.handleOperationWithCompletion(\n      mutation,\n      context,\n      waitForCompletion,\n      // eslint-disable-next-line no-shadow\n      async (tableName, mutation) => {\n        const metadataValue = this.processMutationMetadata(mutation)\n        if (metadataValue != null) {\n          /**\n           * Delete operations with metadata require a different approach to handle metadata.\n           * This will delete the record.\n           */\n          await context.execute(\n            `\n            UPDATE ${tableName} SET _deleted = TRUE, _metadata = ? WHERE id = ?\n            `,\n            [metadataValue, asPowerSyncRecord(mutation.original).id],\n          )\n        } else {\n          await context.execute(\n            `\n            DELETE FROM ${tableName} WHERE id = ?\n            `,\n            [asPowerSyncRecord(mutation.original).id],\n          )\n        }\n      },\n    )\n  }\n\n  /**\n   * Helper function which wraps a persistence operation by:\n   * - Fetching the mutation's collection's SQLite table details\n   * - Executing the mutation\n   * - Returning the last pending diff operation if required\n   */\n  protected async handleOperationWithCompletion(\n    mutation: PendingMutation<any>,\n    context: LockContext,\n    waitForCompletion: boolean,\n    handler: (\n      tableName: string,\n      mutation: PendingMutation<any>,\n      serializeValue: (value: any) => Record<string, unknown>,\n    ) => Promise<void>,\n  ): Promise<PendingOperation | null> {\n    const { tableName, trackedTableName, serializeValue } =\n      this.getMutationCollectionMeta(mutation)\n\n    await handler(sanitizeSQL`${tableName}`, mutation, serializeValue)\n\n    if (!waitForCompletion) {\n      return null\n    }\n\n    // Need to get the operation in order to wait for it\n    const diffOperation = await context.get<{ id: string; timestamp: string }>(\n      sanitizeSQL`SELECT id, timestamp FROM ${trackedTableName} ORDER BY operation_id DESC LIMIT 1`,\n    )\n    return {\n      tableName,\n      id: diffOperation.id,\n      operation: mapOperationToPowerSync(mutation.type),\n      timestamp: diffOperation.timestamp,\n    }\n  }\n\n  protected getMutationCollectionMeta(\n    mutation: PendingMutation<any>,\n  ): PowerSyncCollectionMeta<any> {\n    if (\n      typeof (mutation.collection.config as any).utils?.getMeta != `function`\n    ) {\n      throw new Error(`Collection is not a PowerSync collection.`)\n    }\n    return (\n      mutation.collection\n        .config as unknown as EnhancedPowerSyncCollectionConfig<any>\n    ).utils.getMeta()\n  }\n\n  /**\n   * Processes collection mutation metadata for persistence to the database.\n   * We only support storing string metadata.\n   * @returns null if no metadata should be stored.\n   */\n  protected processMutationMetadata(\n    mutation: PendingMutation<any>,\n  ): string | null {\n    const { metadataIsTracked } = this.getMutationCollectionMeta(mutation)\n    if (!metadataIsTracked) {\n      // If it's not supported, we don't store metadata.\n      if (typeof mutation.metadata != `undefined`) {\n        // Log a warning if metadata is provided but not tracked.\n        this.database.logger.warn(\n          `Metadata provided for collection ${mutation.collection.id} but the PowerSync table does not track metadata. The PowerSync table should be configured with trackMetadata: true.`,\n          mutation.metadata,\n        )\n      }\n      return null\n    } else if (typeof mutation.metadata == `undefined`) {\n      return null\n    } else if (typeof mutation.metadata == `string`) {\n      return mutation.metadata\n    } else {\n      return JSON.stringify(mutation.metadata)\n    }\n  }\n}\n"],"names":["PendingOperationStore","mutation","sanitizeSQL","asPowerSyncRecord","mapOperationToPowerSync"],"mappings":"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"}
+{"version":3,"file":"PowerSyncTransactor.cjs","sources":["../../src/PowerSyncTransactor.ts"],"sourcesContent":["import { sanitizeSQL } from '@powersync/common'\nimport { LoadSubsetOperationAbortedError } from '@tanstack/db'\nimport DebugModule from 'debug'\nimport { PendingOperationStore } from './PendingOperationStore'\nimport { asPowerSyncRecord, mapOperationToPowerSync } from './helpers'\nimport type { AbstractPowerSyncDatabase, LockContext } from '@powersync/common'\nimport type { PendingMutation, Transaction } from '@tanstack/db'\nimport type { PendingOperation } from './PendingOperationStore'\nimport type {\n  EnhancedPowerSyncCollectionConfig,\n  PowerSyncCollectionMeta,\n} from './definitions'\n\nconst debug = DebugModule.debug(`ts/db:powersync`)\n\nexport type TransactorOptions = {\n  database: AbstractPowerSyncDatabase\n}\n\n/**\n * Applies mutations to the PowerSync database. This method is called automatically by the collection's\n * insert, update, and delete operations. You typically don't need to call this directly unless you\n * have special transaction requirements.\n *\n * @example\n * ```typescript\n * // Create a collection\n * const collection = createCollection(\n *   powerSyncCollectionOptions<Document>({\n *     database: db,\n *     table: APP_SCHEMA.props.documents,\n *   })\n * )\n *\n * const addTx = createTransaction({\n *   autoCommit: false,\n *   mutationFn: async ({ transaction }) => {\n *     await new PowerSyncTransactor({ database: db }).applyTransaction(transaction)\n *   },\n * })\n *\n * addTx.mutate(() => {\n *   for (let i = 0; i < 5; i++) {\n *     collection.insert({ id: randomUUID(), name: `tx-${i}` })\n *   }\n * })\n *\n * await addTx.commit()\n * await addTx.isPersisted.promise\n * ```\n *\n * @param transaction - The transaction containing mutations to apply\n * @returns A promise that resolves when the mutations have been persisted to PowerSync\n */\nexport class PowerSyncTransactor {\n  database: AbstractPowerSyncDatabase\n  pendingOperationStore: PendingOperationStore\n\n  constructor(options: TransactorOptions) {\n    this.database = options.database\n    this.pendingOperationStore = PendingOperationStore.GLOBAL\n  }\n\n  /**\n   * Persists a {@link Transaction} to the PowerSync SQLite database.\n   */\n  async applyTransaction(transaction: Transaction<any>) {\n    const { mutations } = transaction\n\n    if (mutations.length == 0) {\n      return\n    }\n    /**\n     * The transaction might contain operations for different collections.\n     * We can do some optimizations for single-collection transactions.\n     */\n    const mutationsCollectionIds = mutations.map(\n      (mutation) => mutation.collection.id,\n    )\n    const collectionIds = Array.from(new Set(mutationsCollectionIds))\n    const lastCollectionMutationIndexes = new Map<string, number>()\n    const allCollections = collectionIds\n      .map((id) => mutations.find((mutation) => mutation.collection.id == id)!)\n      .map((mutation) => mutation.collection)\n    for (const collectionId of collectionIds) {\n      lastCollectionMutationIndexes.set(\n        collectionId,\n        mutationsCollectionIds.lastIndexOf(collectionId),\n      )\n    }\n\n    // Check all the observers are ready before taking a lock\n    await Promise.all(\n      allCollections.map(async (collection) => {\n        if (collection.isReady()) {\n          return\n        }\n        // Observe this session without starting new demand from mutationFn.\n        // Cleanup and startup failure must settle the wait before taking a lock.\n        await new Promise<void>((resolve, reject) => {\n          const check = () => {\n            if (collection.isReady()) {\n              unsubscribe()\n              resolve()\n            } else if (\n              collection.status === `error` ||\n              collection.status === `cleaned-up`\n            ) {\n              unsubscribe()\n              reject(\n                collection.status === `error`\n                  ? (collection._lifecycle.getSyncError() ??\n                      new Error(`Collection failed before readiness`))\n                  : new LoadSubsetOperationAbortedError(),\n              )\n            }\n          }\n          const unsubscribe = collection.on(`status:change`, check)\n          check()\n        })\n      }),\n    )\n\n    // Persist to PowerSync\n    const { whenComplete } = await this.database.writeTransaction(\n      async (tx) => {\n        const pendingOperations: Array<PendingOperation | null> = []\n\n        for (const [index, mutation] of mutations.entries()) {\n          /**\n           * Each collection processes events independently. We need to make sure the\n           * last operation for each collection has been observed.\n           */\n          const shouldWait =\n            index == lastCollectionMutationIndexes.get(mutation.collection.id)\n          switch (mutation.type) {\n            case `insert`:\n              pendingOperations.push(\n                await this.handleInsert(mutation, tx, shouldWait),\n              )\n              break\n            case `update`:\n              pendingOperations.push(\n                await this.handleUpdate(mutation, tx, shouldWait),\n              )\n              break\n            case `delete`:\n              pendingOperations.push(\n                await this.handleDelete(mutation, tx, shouldWait),\n              )\n              break\n          }\n        }\n\n        /**\n         * Return a promise from the writeTransaction, without awaiting it.\n         * This promise will resolve once the entire transaction has been\n         * observed via the diff triggers.\n         * We return without awaiting in order to free the write lock.\n         */\n        return {\n          whenComplete: Promise.all(\n            pendingOperations\n              .filter((op) => !!op)\n              .map((op) => this.pendingOperationStore.waitFor(op)),\n          ),\n        }\n      },\n    )\n\n    // Wait for the change to be observed via the diff trigger\n    await whenComplete\n  }\n\n  protected async handleInsert(\n    mutation: PendingMutation<any>,\n    context: LockContext,\n    waitForCompletion: boolean = false,\n  ): Promise<PendingOperation | null> {\n    debug(`insert`, mutation)\n\n    return this.handleOperationWithCompletion(\n      mutation,\n      context,\n      waitForCompletion,\n      // eslint-disable-next-line no-shadow\n      async (tableName, mutation, serializeValue) => {\n        const values = serializeValue(mutation.modified)\n        const keys = Object.keys(values).map((key) => sanitizeSQL`${key}`)\n        const queryParameters = Object.values(values)\n\n        const metadataValue = this.processMutationMetadata(mutation)\n        if (metadataValue != null) {\n          keys.push(`_metadata`)\n          queryParameters.push(metadataValue)\n        }\n\n        await context.execute(\n          `\n        INSERT into ${tableName}\n            (${keys.join(`, `)})\n        VALUES\n            (${keys.map((_) => `?`).join(`, `)})\n        `,\n          queryParameters,\n        )\n      },\n    )\n  }\n\n  protected async handleUpdate(\n    mutation: PendingMutation<any>,\n    context: LockContext,\n    waitForCompletion: boolean = false,\n  ): Promise<PendingOperation | null> {\n    debug(`update`, mutation)\n\n    return this.handleOperationWithCompletion(\n      mutation,\n      context,\n      waitForCompletion,\n      // eslint-disable-next-line no-shadow\n      async (tableName, mutation, serializeValue) => {\n        const values = serializeValue(mutation.modified)\n        const keys = Object.keys(values).map((key) => sanitizeSQL`${key}`)\n        const queryParameters = Object.values(values)\n\n        const metadataValue = this.processMutationMetadata(mutation)\n        if (metadataValue != null) {\n          keys.push(`_metadata`)\n          queryParameters.push(metadataValue)\n        }\n\n        await context.execute(\n          `\n        UPDATE ${tableName}\n        SET ${keys.map((key) => `${key} = ?`).join(`, `)}\n        WHERE id = ?\n        `,\n          [...queryParameters, asPowerSyncRecord(mutation.modified).id],\n        )\n      },\n    )\n  }\n\n  protected async handleDelete(\n    mutation: PendingMutation<any>,\n    context: LockContext,\n    waitForCompletion: boolean = false,\n  ): Promise<PendingOperation | null> {\n    debug(`update`, mutation)\n\n    return this.handleOperationWithCompletion(\n      mutation,\n      context,\n      waitForCompletion,\n      // eslint-disable-next-line no-shadow\n      async (tableName, mutation) => {\n        const metadataValue = this.processMutationMetadata(mutation)\n        if (metadataValue != null) {\n          /**\n           * Delete operations with metadata require a different approach to handle metadata.\n           * This will delete the record.\n           */\n          await context.execute(\n            `\n            UPDATE ${tableName} SET _deleted = TRUE, _metadata = ? WHERE id = ?\n            `,\n            [metadataValue, asPowerSyncRecord(mutation.original).id],\n          )\n        } else {\n          await context.execute(\n            `\n            DELETE FROM ${tableName} WHERE id = ?\n            `,\n            [asPowerSyncRecord(mutation.original).id],\n          )\n        }\n      },\n    )\n  }\n\n  /**\n   * Helper function which wraps a persistence operation by:\n   * - Fetching the mutation's collection's SQLite table details\n   * - Executing the mutation\n   * - Returning the last pending diff operation if required\n   */\n  protected async handleOperationWithCompletion(\n    mutation: PendingMutation<any>,\n    context: LockContext,\n    waitForCompletion: boolean,\n    handler: (\n      tableName: string,\n      mutation: PendingMutation<any>,\n      serializeValue: (value: any) => Record<string, unknown>,\n    ) => Promise<void>,\n  ): Promise<PendingOperation | null> {\n    const { tableName, trackedTableName, serializeValue } =\n      this.getMutationCollectionMeta(mutation)\n\n    await handler(sanitizeSQL`${tableName}`, mutation, serializeValue)\n\n    if (!waitForCompletion) {\n      return null\n    }\n\n    // Need to get the operation in order to wait for it\n    const diffOperation = await context.get<{ id: string; timestamp: string }>(\n      sanitizeSQL`SELECT id, timestamp FROM ${trackedTableName} ORDER BY operation_id DESC LIMIT 1`,\n    )\n    return {\n      tableName,\n      id: diffOperation.id,\n      operation: mapOperationToPowerSync(mutation.type),\n      timestamp: diffOperation.timestamp,\n    }\n  }\n\n  protected getMutationCollectionMeta(\n    mutation: PendingMutation<any>,\n  ): PowerSyncCollectionMeta<any> {\n    if (\n      typeof (mutation.collection.config as any).utils?.getMeta != `function`\n    ) {\n      throw new Error(`Collection is not a PowerSync collection.`)\n    }\n    return (\n      mutation.collection\n        .config as unknown as EnhancedPowerSyncCollectionConfig<any>\n    ).utils.getMeta()\n  }\n\n  /**\n   * Processes collection mutation metadata for persistence to the database.\n   * We only support storing string metadata.\n   * @returns null if no metadata should be stored.\n   */\n  protected processMutationMetadata(\n    mutation: PendingMutation<any>,\n  ): string | null {\n    const { metadataIsTracked } = this.getMutationCollectionMeta(mutation)\n    if (!metadataIsTracked) {\n      // If it's not supported, we don't store metadata.\n      if (typeof mutation.metadata != `undefined`) {\n        // Log a warning if metadata is provided but not tracked.\n        this.database.logger.warn(\n          `Metadata provided for collection ${mutation.collection.id} but the PowerSync table does not track metadata. The PowerSync table should be configured with trackMetadata: true.`,\n          mutation.metadata,\n        )\n      }\n      return null\n    } else if (typeof mutation.metadata == `undefined`) {\n      return null\n    } else if (typeof mutation.metadata == `string`) {\n      return mutation.metadata\n    } else {\n      return JSON.stringify(mutation.metadata)\n    }\n  }\n}\n"],"names":["PendingOperationStore","LoadSubsetOperationAbortedError","mutation","sanitizeSQL","asPowerSyncRecord","mapOperationToPowerSync"],"mappings":"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"}

package/dist/cjs/powersync.cjs

@@ -59,12 +59,17 @@ function createPowerSyncCollectionConfig(config) {
       const { begin, write, collection, commit, markReady, markError } = params;
       const abortController = new AbortController();
       let disposeTracking = null;
+      let trackingSetup = null;
       if (syncMode === `eager`) {
         return runEagerSync();
       } else {
         return runOnDemandSync();
       }
       async function safelyDisposeTracking(context) {
+        const setup = trackingSetup;
+        if (setup) {
+          await setup.catch(() => void 0);
+        }
         const dispose = disposeTracking;
         if (!dispose) {
           return;
@@ -72,6 +77,20 @@ function createPowerSyncCollectionConfig(config) {
         disposeTracking = null;
         await dispose(context ? { context } : void 0);
       }
+      async function establishTracking(options, appliedReceipts) {
+        const setup = (async () => {
+          const dispose = await createDiffTrigger(options, appliedReceipts);
+          disposeTracking = dispose;
+        })();
+        trackingSetup = setup;
+        try {
+          await setup;
+        } finally {
+          if (trackingSetup === setup) {
+            trackingSetup = null;
+          }
+        }
+      }
       async function createDiffTrigger(options, appliedReceipts) {
         const { setupContext, immediate, when, writeType, batchQuery } = options;
         return await database.triggers.createDiffTrigger({
@@ -108,6 +127,13 @@ function createPowerSyncCollectionConfig(config) {
         });
       }
       async function flushDiffRecords() {
+        const setup = trackingSetup;
+        if (setup) {
+          await setup.catch(() => void 0);
+        }
+        if (!disposeTracking) {
+          return;
+        }
         const ignoredReceipts = [];
         await database.writeTransaction(async (context) => {
           await flushDiffRecordsWithContext(context, ignoredReceipts);
@@ -193,9 +219,14 @@ function createPowerSyncCollectionConfig(config) {
       function runEagerSync() {
         let onUnload = null;
         start(async () => {
-          onUnload = await restConfig.onLoad?.();
+          const cleanup = await restConfig.onLoad?.();
+          if (abortController.signal.aborted) {
+            cleanup?.();
+            return;
+          }
+          onUnload = cleanup;
           const appliedReceipts = [];
-          disposeTracking = await createDiffTrigger(
+          await establishTracking(
             {
               // Initial eager hydration must make the source usable before
               // PowerSync can persist a mutation queued during startup.
@@ -233,81 +264,114 @@ function createPowerSyncCollectionConfig(config) {
         };
       }
       function runOnDemandSync() {
-        const unloadSubsetCallbacks = /* @__PURE__ */ new Map();
+        const demands = /* @__PURE__ */ new Map();
         const releasedSubsets = /* @__PURE__ */ new WeakSet();
+        const pendingReleases = [];
         let stopped = false;
-        const hasStopped = () => stopped;
-        start().catch(
+        let trackingRevision = 0;
+        let reconciledTrackingRevision = 0;
+        let rebuildPromise = null;
+        let drainingReleases = false;
+        let releaseRetryTimer;
+        const startup = start();
+        void startup.catch(
           (error) => database.logger.error(
             `Could not start syncing process for ${viewName} into ${trackedTableName}`,
             error
           )
         );
-        const activeWhereExpressions = [];
-        const loadSubset = async (options) => {
-          if (hasStopped()) return;
-          const appliedReceipts = [];
-          if (options) {
-            activeWhereExpressions.push(options.where);
-            const cleanup = await restConfig.onLoadSubset?.(options);
-            if (hasStopped()) {
-              cleanup?.();
-              return;
-            }
-            if (cleanup) {
-              if (releasedSubsets.has(options) || options.signal?.aborted) {
-                cleanup();
-              } else {
-                unloadSubsetCallbacks.set(options, cleanup);
-              }
-            }
-          }
-          if (activeWhereExpressions.length === 0) {
+        const activeWhereExpressions = () => Array.from(demands.values()).filter((demand) => demand.active).map((demand) => demand.options.where);
+        const reconcileTracking = async () => {
+          while (!stopped && reconciledTrackingRevision !== trackingRevision) {
+            const revision = trackingRevision;
+            const isCurrent = () => !stopped && trackingRevision === revision;
+            const appliedReceipts = [];
             await database.writeLock(async (ctx) => {
+              if (!isCurrent()) return;
               await flushDiffRecordsWithContext(ctx, appliedReceipts);
+              if (!isCurrent()) return;
               await safelyDisposeTracking(ctx);
+              if (!isCurrent()) return;
+              const active = activeWhereExpressions();
+              if (active.length === 0) return;
+              const combinedWhere = active.length === 1 ? active[0] : db.or(active[0], active[1], ...active.slice(2));
+              const compiledNewData = sqliteCompiler.compileSQLite(
+                { where: combinedWhere },
+                { jsonColumn: "NEW.data" }
+              );
+              const compiledOldData = sqliteCompiler.compileSQLite(
+                { where: combinedWhere },
+                { jsonColumn: "OLD.data" }
+              );
+              const compiledView = sqliteCompiler.compileSQLite({ where: combinedWhere });
+              const newDataWhenClause = toInlinedWhereClause(compiledNewData);
+              const oldDataWhenClause = toInlinedWhereClause(compiledOldData);
+              const viewWhereClause = toInlinedWhereClause(compiledView);
+              await establishTracking(
+                {
+                  setupContext: ctx,
+                  when: {
+                    [common.DiffTriggerOperation.INSERT]: newDataWhenClause,
+                    [common.DiffTriggerOperation.UPDATE]: `(${newDataWhenClause}) OR (${oldDataWhenClause})`,
+                    [common.DiffTriggerOperation.DELETE]: oldDataWhenClause
+                  },
+                  writeType: (rowId) => collection.has(rowId) ? `update` : `insert`,
+                  batchQuery: (lockContext, batchSize, cursor) => lockContext.getAll(
+                    `SELECT * FROM ${viewName} WHERE ${viewWhereClause} LIMIT ? OFFSET ?`,
+                    [batchSize, cursor]
+                  )
+                },
+                appliedReceipts
+              );
+              if (!isCurrent()) await safelyDisposeTracking(ctx);
             });
             await Promise.all(appliedReceipts);
+            if (isCurrent()) {
+              reconciledTrackingRevision = revision;
+            }
+          }
+        };
+        const rebuildTracking = async () => {
+          while (!stopped && reconciledTrackingRevision !== trackingRevision) {
+            await (rebuildPromise ??= reconcileTracking().catch((error) => {
+              if (!stopped) markError(error);
+              throw error;
+            }).finally(() => {
+              rebuildPromise = null;
+            }));
+          }
+        };
+        const loadSubset = async (options) => {
+          if (stopped) return;
+          await startup;
+          if (
+            // Cleanup can run while startup is pending.
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            stopped || releasedSubsets.has(options) || options.signal?.aborted
+          ) {
             return;
           }
-          const combinedWhere = activeWhereExpressions.length === 1 ? activeWhereExpressions[0] : db.or(
-            activeWhereExpressions[0],
-            activeWhereExpressions[1],
-            ...activeWhereExpressions.slice(2)
-          );
-          const compiledNewData = sqliteCompiler.compileSQLite(
-            { where: combinedWhere },
-            { jsonColumn: "NEW.data" }
-          );
-          const compiledOldData = sqliteCompiler.compileSQLite(
-            { where: combinedWhere },
-            { jsonColumn: "OLD.data" }
-          );
-          const compiledView = sqliteCompiler.compileSQLite({ where: combinedWhere });
-          const newDataWhenClause = toInlinedWhereClause(compiledNewData);
-          const oldDataWhenClause = toInlinedWhereClause(compiledOldData);
-          const viewWhereClause = toInlinedWhereClause(compiledView);
-          await database.writeLock(async (ctx) => {
-            await flushDiffRecordsWithContext(ctx, appliedReceipts);
-            await safelyDisposeTracking(ctx);
-            disposeTracking = await createDiffTrigger(
-              {
-                setupContext: ctx,
-                when: {
-                  [common.DiffTriggerOperation.INSERT]: newDataWhenClause,
-                  [common.DiffTriggerOperation.UPDATE]: `(${newDataWhenClause}) OR (${oldDataWhenClause})`,
-                  [common.DiffTriggerOperation.DELETE]: oldDataWhenClause
-                },
-                writeType: (rowId) => collection.has(rowId) ? `update` : `insert`,
-                batchQuery: (lockContext, batchSize, cursor) => lockContext.getAll(
-                  `SELECT * FROM ${viewName} WHERE ${viewWhereClause} LIMIT ? OFFSET ?`,
-                  [batchSize, cursor]
-                )
-              },
-              appliedReceipts
-            );
-          });
-          await Promise.all(appliedReceipts);
+          const demand = { options, active: false };
+          demands.set(options, demand);
+          try {
+            const cleanup = await restConfig.onLoadSubset?.(options);
+            if (cleanup) demand.cleanup = cleanup;
+          } catch (error) {
+            demands.delete(options);
+            throw error;
+          }
+          if (
+            // The user hook can reenter cleanup.
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            stopped || releasedSubsets.has(options) || options.signal?.aborted || demands.get(options) !== demand
+          ) {
+            demands.delete(options);
+            demand.cleanup?.();
+            return;
+          }
+          demand.active = true;
+          trackingRevision++;
+          await rebuildTracking();
         };
         const toInlinedWhereClause = (compiled) => {
           if (!compiled.where) return "TRUE";
@@ -317,32 +381,40 @@ function createPowerSyncCollectionConfig(config) {
             ...compiled.params
           );
         };
-        const unloadSubset = async (options) => {
-          releasedSubsets.add(options);
-          unloadSubsetCallbacks.get(options)?.();
-          unloadSubsetCallbacks.delete(options);
-          const idx = activeWhereExpressions.indexOf(options.where);
-          if (idx !== -1) {
-            activeWhereExpressions.splice(idx, 1);
+        const cleanupDemand = (demand) => {
+          demands.delete(demand.options);
+          try {
+            demand.cleanup?.();
+          } catch (error) {
+            database.logger.error(
+              `Could not clean up subset hook for ${viewName}`,
+              error
+            );
           }
+        };
+        const performPhysicalRelease = async (options) => {
           const compiledDeparting = sqliteCompiler.compileSQLite({ where: options.where });
           const departingWhereSQL = toInlinedWhereClause(compiledDeparting);
-          let evictionSQL;
-          if (activeWhereExpressions.length === 0) {
-            evictionSQL = `SELECT id FROM ${viewName} WHERE ${departingWhereSQL}`;
-          } else {
-            const combinedRemaining = activeWhereExpressions.length === 1 ? activeWhereExpressions[0] : db.or(
-              activeWhereExpressions[0],
-              activeWhereExpressions[1],
-              ...activeWhereExpressions.slice(2)
-            );
-            const compiledRemaining = sqliteCompiler.compileSQLite({
-              where: combinedRemaining
-            });
-            const remainingWhereSQL = toInlinedWhereClause(compiledRemaining);
-            evictionSQL = `SELECT id FROM ${viewName} WHERE (${departingWhereSQL}) AND NOT (${remainingWhereSQL})`;
+          let rowsToEvict;
+          for (; ; ) {
+            if (stopped) return;
+            const revision = trackingRevision;
+            const active = activeWhereExpressions();
+            let evictionSQL;
+            if (active.length === 0) {
+              evictionSQL = `SELECT id FROM ${viewName} WHERE ${departingWhereSQL}`;
+            } else {
+              const combinedRemaining = active.length === 1 ? active[0] : db.or(active[0], active[1], ...active.slice(2));
+              const compiledRemaining = sqliteCompiler.compileSQLite({
+                where: combinedRemaining
+              });
+              const remainingWhereSQL = toInlinedWhereClause(compiledRemaining);
+              evictionSQL = `SELECT id FROM ${viewName} WHERE (${departingWhereSQL}) AND NOT (${remainingWhereSQL})`;
+            }
+            rowsToEvict = await database.getAll(evictionSQL);
+            if (stopped) return;
+            if (trackingRevision === revision) break;
           }
-          const rowsToEvict = await database.getAll(evictionSQL);
           if (rowsToEvict.length > 0) {
             begin();
             for (const { id } of rowsToEvict) {
@@ -350,22 +422,79 @@ function createPowerSyncCollectionConfig(config) {
             }
             void commit();
           }
-          await loadSubset();
+          await rebuildTracking();
+        };
+        function scheduleReleaseDrain(delay = 0) {
+          if (stopped || drainingReleases || releaseRetryTimer) return;
+          if (delay > 0) {
+            releaseRetryTimer = setTimeout(() => {
+              releaseRetryTimer = void 0;
+              void drainReleases();
+            }, delay);
+            return;
+          }
+          void drainReleases();
+        }
+        async function drainReleases() {
+          if (stopped || drainingReleases) return;
+          drainingReleases = true;
+          let retryDelay = 0;
+          try {
+            const attempts = pendingReleases.length;
+            for (let index = 0; !stopped && index < attempts; index++) {
+              const pending = pendingReleases.shift();
+              try {
+                await performPhysicalRelease(pending.options);
+              } catch (error) {
+                pending.failures++;
+                pendingReleases.push(pending);
+                const delay = Math.min(
+                  1e3 * 2 ** (pending.failures - 1),
+                  3e4
+                );
+                retryDelay = retryDelay === 0 ? delay : Math.min(retryDelay, delay);
+                database.logger.error(
+                  `Could not release subset tracking for ${viewName}; retrying`,
+                  error
+                );
+              }
+            }
+          } finally {
+            drainingReleases = false;
+          }
+          if (pendingReleases.length > 0) scheduleReleaseDrain(retryDelay);
+        }
+        const unloadSubset = (options) => {
+          releasedSubsets.add(options);
+          const demand = demands.get(options);
+          if (!demand) return;
+          const wasActive = demand.active;
+          if (wasActive) trackingRevision++;
+          cleanupDemand(demand);
+          if (wasActive) {
+            pendingReleases.push({ options, failures: 0 });
+            clearTimeout(releaseRetryTimer);
+            releaseRetryTimer = void 0;
+            scheduleReleaseDrain();
+          }
         };
         markReady();
         return {
           cleanup: () => {
             stopped = true;
+            clearTimeout(releaseRetryTimer);
+            releaseRetryTimer = void 0;
             database.logger.info(
               `Sync has been stopped for ${viewName} into ${trackedTableName}`
             );
             abortController.abort();
-            for (const cleanup of unloadSubsetCallbacks.values()) cleanup();
-            unloadSubsetCallbacks.clear();
-            activeWhereExpressions.length = 0;
+            for (const demand of demands.values()) {
+              cleanupDemand(demand);
+            }
+            pendingReleases.length = 0;
           },
           loadSubset: (options) => loadSubset(options),
-          unloadSubset: (options) => unloadSubset(options)
+          unloadSubset
         };
       }
     },