@tanstack/powersync-db-collection 0.1.67 → 0.2.1

package/dist/cjs/powersync.cjs

@@ -9,6 +9,9 @@ const definitions = require("./definitions.cjs");
 const helpers = require("./helpers.cjs");
 const schema = require("./schema.cjs");
 const serialization = require("./serialization.cjs");
+function isPromiseLike(value) {
+  return !!value && (typeof value === `object` || typeof value === `function`) && typeof value.then === `function`;
+}
 function powerSyncCollectionOptions(config) {
   const outputConfig = createPowerSyncCollectionConfig(config);
   return db.withCollectionConfigFactory(
@@ -36,12 +39,15 @@ function createPowerSyncCollectionConfig(config) {
       return validation.value;
     } else if (`issues` in validation) {
       const issueMessage = `Failed to validate incoming data for ${viewName}. Issues: ${validation.issues.map((issue) => `${issue.path} - ${issue.message}`)}`;
-      database.logger.error(issueMessage);
+      database.logger.log({ level: common.LogLevels.error, message: issueMessage });
       onDeserializationError(validation);
       throw new Error(issueMessage);
     } else {
       const unknownErrorMessage = `Unknown deserialization error for ${viewName}`;
-      database.logger.error(unknownErrorMessage);
+      database.logger.log({
+        level: common.LogLevels.error,
+        message: unknownErrorMessage
+      });
       onDeserializationError({ issues: [{ message: unknownErrorMessage }] });
       throw new Error(unknownErrorMessage);
     }
@@ -60,6 +66,8 @@ function createPowerSyncCollectionConfig(config) {
       const abortController = new AbortController();
       let disposeTracking = null;
       let trackingSetup = null;
+      let activeTrackingDisposal = null;
+      let abortTrackingDisposal = null;
       if (syncMode === `eager`) {
         return runEagerSync();
       } else {
@@ -72,10 +80,29 @@ function createPowerSyncCollectionConfig(config) {
         }
         const dispose = disposeTracking;
         if (!dispose) {
+          await activeTrackingDisposal;
           return;
         }
         disposeTracking = null;
-        await dispose(context ? { context } : void 0);
+        let disposal;
+        try {
+          disposal = Promise.resolve(dispose(context ? { context } : void 0));
+        } catch (error) {
+          disposal = Promise.reject(error);
+        }
+        activeTrackingDisposal = disposal;
+        try {
+          await disposal;
+        } finally {
+          if (activeTrackingDisposal === disposal) {
+            activeTrackingDisposal = null;
+          }
+        }
+      }
+      function disposeTrackingAfterAbort() {
+        const disposal = abortTrackingDisposal ??= safelyDisposeTracking();
+        void disposal.catch(() => void 0);
+        return disposal;
       }
       async function establishTracking(options, appliedReceipts) {
         const setup = (async () => {
@@ -96,6 +123,7 @@ function createPowerSyncCollectionConfig(config) {
         return await database.triggers.createDiffTrigger({
           source: viewName,
           destination: trackedTableName,
+          columns: table.columns.map((column) => column.name),
           setupContext,
           when,
           hooks: {
@@ -119,9 +147,10 @@ function createPowerSyncCollectionConfig(config) {
                 }
                 appliedReceipts.push(commit());
               }
-              database.logger.info(
-                `Sync is ready for ${viewName} into ${trackedTableName}`
-              );
+              database.logger.log({
+                level: common.LogLevels.info,
+                message: `Sync is ready for ${viewName} into ${trackedTableName}`
+              });
             }
           }
         });
@@ -138,10 +167,11 @@ function createPowerSyncCollectionConfig(config) {
         await database.writeTransaction(async (context) => {
           await flushDiffRecordsWithContext(context, ignoredReceipts);
         }).catch((error) => {
-          database.logger.error(
-            `An error has been detected in the sync handler`,
+          database.logger.log({
+            level: common.LogLevels.error,
+            message: `An error has been detected in the sync handler`,
             error
-          );
+          });
         });
       }
       async function flushDiffRecordsWithContext(context, appliedReceipts) {
@@ -181,16 +211,18 @@ function createPowerSyncCollectionConfig(config) {
           appliedReceipts.push(applied);
           pendingOperationStore.resolvePendingFor(pendingOperations);
         } catch (error) {
-          database.logger.error(
-            `An error has been detected in the sync handler`,
+          database.logger.log({
+            level: common.LogLevels.error,
+            message: `An error has been detected in the sync handler`,
             error
-          );
+          });
         }
       }
       async function start(afterOnChangeRegistered) {
-        database.logger.info(
-          `Sync is starting for ${viewName} into ${trackedTableName}`
-        );
+        database.logger.log({
+          level: common.LogLevels.info,
+          message: `Sync is starting for ${viewName} into ${trackedTableName}`
+        });
         database.onChangeWithCallback(
           {
             onChange: async () => {
@@ -205,12 +237,12 @@ function createPowerSyncCollectionConfig(config) {
         );
         await afterOnChangeRegistered?.();
         if (abortController.signal.aborted) {
-          await safelyDisposeTracking();
+          await disposeTrackingAfterAbort();
         } else {
           abortController.signal.addEventListener(
             `abort`,
-            async () => {
-              await safelyDisposeTracking();
+            () => {
+              void disposeTrackingAfterAbort();
             },
             { once: true }
           );
@@ -218,13 +250,13 @@ function createPowerSyncCollectionConfig(config) {
       }
       function runEagerSync() {
         let onUnload = null;
-        start(async () => {
+        let onUnloadStarted = false;
+        const startup = start(async () => {
           const cleanup = await restConfig.onLoad?.();
+          onUnload = cleanup;
           if (abortController.signal.aborted) {
-            cleanup?.();
             return;
           }
-          onUnload = cleanup;
           const appliedReceipts = [];
           await establishTracking(
             {
@@ -247,38 +279,77 @@ function createPowerSyncCollectionConfig(config) {
           await Promise.all(appliedReceipts);
           markReady();
         }).catch((error) => {
-          database.logger.error(
-            `Could not start syncing process for ${viewName} into ${trackedTableName}`,
+          database.logger.log({
+            level: common.LogLevels.error,
+            message: `Could not start syncing process for ${viewName} into ${trackedTableName}`,
             error
-          );
+          });
           if (collection.status === `loading`) {
             markError(error);
           }
         });
-        return () => {
-          database.logger.info(
-            `Sync has been stopped for ${viewName} into ${trackedTableName}`
-          );
+        const invokeOnUnload = () => {
+          if (onUnloadStarted || !onUnload) return;
+          onUnloadStarted = true;
+          const cleanup = onUnload;
+          onUnload = null;
+          return cleanup();
+        };
+        return async () => {
+          database.logger.log({
+            level: common.LogLevels.info,
+            message: `Sync has been stopped for ${viewName} into ${trackedTableName}`
+          });
           abortController.abort();
-          onUnload?.();
+          const trackingDisposal = disposeTrackingAfterAbort();
+          let onUnloadFailure;
+          const settleOnUnload = async () => {
+            try {
+              await invokeOnUnload();
+            } catch (error) {
+              onUnloadFailure ??= { error };
+            }
+          };
+          const settlements = await Promise.allSettled([
+            startup,
+            trackingDisposal,
+            settleOnUnload()
+          ]);
+          const disposalSettlement = settlements[1];
+          await settleOnUnload();
+          if (disposalSettlement.status === `rejected` && onUnloadFailure) {
+            throw new AggregateError(
+              [disposalSettlement.reason, onUnloadFailure.error],
+              `PowerSync tracking disposal and load-hook cleanup both failed`,
+              { cause: disposalSettlement.reason }
+            );
+          }
+          if (disposalSettlement.status === `rejected`) {
+            throw disposalSettlement.reason;
+          }
+          if (onUnloadFailure) throw onUnloadFailure.error;
         };
       }
       function runOnDemandSync() {
         const demands = /* @__PURE__ */ new Map();
         const releasedSubsets = /* @__PURE__ */ new WeakSet();
         const pendingReleases = [];
+        const pendingDemandLoads = /* @__PURE__ */ new Set();
+        const pendingDemandCleanups = /* @__PURE__ */ new Set();
         let stopped = false;
         let trackingRevision = 0;
         let reconciledTrackingRevision = 0;
         let rebuildPromise = null;
         let drainingReleases = false;
         let releaseRetryTimer;
+        let demandCleanupCollector = null;
         const startup = start();
         void startup.catch(
-          (error) => database.logger.error(
-            `Could not start syncing process for ${viewName} into ${trackedTableName}`,
+          (error) => database.logger.log({
+            level: common.LogLevels.error,
+            message: `Could not start syncing process for ${viewName} into ${trackedTableName}`,
             error
-          )
+          })
         );
         const activeWhereExpressions = () => Array.from(demands.values()).filter((demand) => demand.active).map((demand) => demand.options.where);
         const reconcileTracking = async () => {
@@ -293,41 +364,52 @@ function createPowerSyncCollectionConfig(config) {
               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
+              const missing = collection.status === `error` ? new Set(collection.keys()) : void 0;
+              if (active.length > 0) {
+                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]
+                    ).then((rows) => {
+                      for (const row of rows) missing?.delete(row.id);
+                      return rows;
+                    })
                   },
-                  writeType: (rowId) => collection.has(rowId) ? `update` : `insert`,
-                  batchQuery: (lockContext, batchSize, cursor) => lockContext.getAll(
-                    `SELECT * FROM ${viewName} WHERE ${viewWhereClause} LIMIT ? OFFSET ?`,
-                    [batchSize, cursor]
-                  )
-                },
-                appliedReceipts
-              );
+                  appliedReceipts
+                );
+              }
               if (!isCurrent()) await safelyDisposeTracking(ctx);
+              else if (missing?.size) {
+                begin();
+                for (const key of missing) write({ type: `delete`, key });
+                appliedReceipts.push(commit());
+              }
             });
             await Promise.all(appliedReceipts);
             if (isCurrent()) {
               reconciledTrackingRevision = revision;
+              if (collection.status === `error`) markReady();
             }
           }
         };
@@ -358,6 +440,13 @@ function createPowerSyncCollectionConfig(config) {
             if (cleanup) demand.cleanup = cleanup;
           } catch (error) {
             demands.delete(options);
+            const collector = demandCleanupCollector;
+            if (collector) {
+              collector.failures.push({
+                order: collector.nextOrder++,
+                error
+              });
+            }
             throw error;
           }
           if (
@@ -365,14 +454,20 @@ function createPowerSyncCollectionConfig(config) {
             // 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?.();
+            cleanupDemand(demand);
             return;
           }
           demand.active = true;
           trackingRevision++;
           await rebuildTracking();
         };
+        const trackLoadSubset = (options) => {
+          const task = loadSubset(options);
+          pendingDemandLoads.add(task);
+          const finish = () => pendingDemandLoads.delete(task);
+          void task.then(finish, finish);
+          return task;
+        };
         const toInlinedWhereClause = (compiled) => {
           if (!compiled.where) return "TRUE";
           const sqlParts = compiled.where.split("?");
@@ -381,15 +476,55 @@ function createPowerSyncCollectionConfig(config) {
             ...compiled.params
           );
         };
+        const reportDemandCleanupFailure = (error) => {
+          database.logger.log({
+            level: common.LogLevels.error,
+            message: `Could not clean up subset hook for ${viewName}`,
+            error
+          });
+        };
         const cleanupDemand = (demand) => {
           demands.delete(demand.options);
+          const collector = demandCleanupCollector;
+          const order = collector ? collector.nextOrder++ : void 0;
           try {
-            demand.cleanup?.();
+            const cleanup = demand.cleanup;
+            demand.cleanup = void 0;
+            const result = cleanup?.();
+            if (!isPromiseLike(result)) return;
+            const task = Promise.resolve(result);
+            pendingDemandCleanups.add(task);
+            const finish = () => pendingDemandCleanups.delete(task);
+            void task.then(finish, finish);
+            if (collector) {
+              collector.tasks.push({ order, promise: task });
+              collector.ownedTasks.add(task);
+              void task.catch(() => void 0);
+            } else {
+              void task.catch((error) => {
+                if (!demandCleanupCollector?.ownedTasks.has(task)) {
+                  reportDemandCleanupFailure(error);
+                }
+              });
+            }
           } catch (error) {
-            database.logger.error(
-              `Could not clean up subset hook for ${viewName}`,
-              error
-            );
+            if (collector) {
+              collector.failures.push({ order, error });
+            } else {
+              reportDemandCleanupFailure(error);
+            }
+          }
+        };
+        const throwDemandCleanupFailures = (collector, primaryFailures = []) => {
+          const errors = [
+            ...primaryFailures,
+            ...collector.failures.slice().sort((left, right) => left.order - right.order).map(({ error }) => error)
+          ];
+          if (errors.length === 1) throw errors[0];
+          if (errors.length > 1) {
+            throw new AggregateError(errors, `PowerSync cleanup failed`, {
+              cause: errors[0]
+            });
           }
         };
         const performPhysicalRelease = async (options) => {
@@ -453,10 +588,11 @@ function createPowerSyncCollectionConfig(config) {
                   3e4
                 );
                 retryDelay = retryDelay === 0 ? delay : Math.min(retryDelay, delay);
-                database.logger.error(
-                  `Could not release subset tracking for ${viewName}; retrying`,
+                database.logger.log({
+                  level: common.LogLevels.error,
+                  message: `Could not release subset tracking for ${viewName}; retrying`,
                   error
-                );
+                });
               }
             }
           } finally {
@@ -484,16 +620,58 @@ function createPowerSyncCollectionConfig(config) {
             stopped = true;
             clearTimeout(releaseRetryTimer);
             releaseRetryTimer = void 0;
-            database.logger.info(
-              `Sync has been stopped for ${viewName} into ${trackedTableName}`
-            );
+            database.logger.log({
+              level: common.LogLevels.info,
+              message: `Sync has been stopped for ${viewName} into ${trackedTableName}`
+            });
             abortController.abort();
+            const trackingDisposal = disposeTrackingAfterAbort();
+            const pendingLoads = [...pendingDemandLoads];
+            const pendingTasks = [...pendingDemandCleanups];
+            const collector = {
+              tasks: pendingTasks.map((promise, order) => ({ order, promise })),
+              ownedTasks: new Set(pendingTasks),
+              failures: [],
+              nextOrder: pendingTasks.length
+            };
+            demandCleanupCollector = collector;
             for (const demand of demands.values()) {
               cleanupDemand(demand);
             }
             pendingReleases.length = 0;
+            return (async () => {
+              const ownershipSettlements = await Promise.allSettled([
+                trackingDisposal,
+                ...pendingLoads
+              ]);
+              const disposalSettlement = ownershipSettlements[0];
+              let settledTasks = 0;
+              while (settledTasks < collector.tasks.length) {
+                const tasks = collector.tasks.slice(settledTasks);
+                settledTasks = collector.tasks.length;
+                const outcomes = await Promise.allSettled(
+                  tasks.map(({ promise }) => promise)
+                );
+                for (const [index, outcome] of outcomes.entries()) {
+                  if (outcome.status === `rejected`) {
+                    collector.failures.push({
+                      order: tasks[index].order,
+                      error: outcome.reason
+                    });
+                  }
+                }
+              }
+              throwDemandCleanupFailures(
+                collector,
+                disposalSettlement.status === `rejected` ? [disposalSettlement.reason] : []
+              );
+            })().finally(() => {
+              if (demandCleanupCollector === collector) {
+                demandCleanupCollector = null;
+              }
+            });
           },
-          loadSubset: (options) => loadSubset(options),
+          loadSubset: trackLoadSubset,
           unloadSubset
         };
       }
@@ -524,13 +702,7 @@ function createPowerSyncCollectionConfig(config) {
         tableName: viewName,
         trackedTableName,
         metadataIsTracked,
-        serializeValue: (value) => serialization.serializeForSQLite(
-          value,
-          // This is required by the input generic
-          table,
-          // Coerce serializer to the shape that corresponds to the Table constructed from OutputType
-          serializer
-        )
+        serializeValue: (value) => serialization.serializeForSQLite(value, table, serializer)
       })
     }
   };