Function runOnDemandSync

packages/powersync-db-collection/src/powersync.ts:510–662

()

      // On-demand mode.
      // Registers a diff trigger for the active WHERE expressions.
      function runOnDemandSync() {
        let onUnloadSubset: CleanupFn | void | null = null

        start().catch((error) =>
          database.logger.error(
            `Could not start syncing process for ${viewName} into ${trackedTableName}`,
            error,
          ),
        )

        // Tracks all active WHERE expressions for on-demand sync filtering.
        // Each loadSubset call pushes its predicate; unloadSubset removes it.
        const activeWhereExpressions: Array<LoadSubsetOptions['where']> = []

        const loadSubset = async (
          options?: LoadSubsetOptions,
        ): Promise<void> => {
          if (options) {
            activeWhereExpressions.push(options.where)
            onUnloadSubset = await restConfig.onLoadSubset?.(options)
          }

          if (activeWhereExpressions.length === 0) {
            await database.writeLock(async (ctx) => {
              await flushDiffRecordsWithContext(ctx)
              await disposeTracking?.({ context: ctx })
            })
            return
          }

          const combinedWhere =
            activeWhereExpressions.length === 1
              ? activeWhereExpressions[0]
              : or(
                  activeWhereExpressions[0],
                  activeWhereExpressions[1],
                  ...activeWhereExpressions.slice(2),
                )

          const compiledNewData = compileSQLite(
            { where: combinedWhere },
            { jsonColumn: 'NEW.data' },
          )

          const compiledOldData = compileSQLite(
            { where: combinedWhere },
            { jsonColumn: 'OLD.data' },
          )

          const compiledView = compileSQLite({ where: combinedWhere })

          const newDataWhenClause = toInlinedWhereClause(compiledNewData)
          const oldDataWhenClause = toInlinedWhereClause(compiledOldData)
          const viewWhereClause = toInlinedWhereClause(compiledView)

          await database.writeLock(async (ctx) => {
            await flushDiffRecordsWithContext(ctx)
            await disposeTracking?.({ context: ctx })