@powersync/service-module-postgres-storage 0.0.0-dev-20260225160713 → 0.0.0-dev-20260511080634

package/dist/utils/utils-index.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils-index.js","sourceRoot":"","sources":["../../src/utils/utils-index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,kBAAkB,CAAC;AACjC,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC;AAC9B,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAC"}
+{"version":3,"file":"utils-index.js","sourceRoot":"","sources":["../../src/utils/utils-index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,kBAAkB,CAAC;AACjC,cAAc,SAAS,CAAC;AACxB,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAC;AAC9C,cAAc,eAAe,CAAC"}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@powersync/service-module-postgres-storage",
   "repository": "https://github.com/powersync-ja/powersync-service",
   "types": "dist/@types/index.d.ts",
-  "version": "0.0.0-dev-20260225160713",
+  "version": "0.0.0-dev-20260511080634",
   "main": "dist/index.js",
   "license": "FSL-1.1-ALv2",
   "type": "module",
@@ -26,25 +26,24 @@
   "dependencies": {
     "ix": "^5.0.0",
     "lru-cache": "^10.2.2",
-    "p-defer": "^4.0.1",
     "ts-codec": "^1.3.0",
-    "uuid": "^11.1.0",
-    "@powersync/lib-service-postgres": "0.0.0-dev-20260225160713",
-    "@powersync/lib-services-framework": "0.0.0-dev-20260225160713",
-    "@powersync/service-core": "0.0.0-dev-20260225160713",
-    "@powersync/service-types": "0.0.0-dev-20260225160713",
-    "@powersync/service-jpgwire": "0.0.0-dev-20260225160713",
-    "@powersync/service-jsonbig": "0.17.12",
-    "@powersync/service-sync-rules": "0.0.0-dev-20260225160713"
+    "uuid": "^14.0.0",
+    "@powersync/lib-service-postgres": "0.0.0-dev-20260511080634",
+    "@powersync/lib-services-framework": "0.0.0-dev-20260511080634",
+    "@powersync/service-core": "0.0.0-dev-20260511080634",
+    "@powersync/service-types": "0.0.0-dev-20260511080634",
+    "@powersync/service-jpgwire": "0.0.0-dev-20260511080634",
+    "@powersync/service-jsonbig": "0.0.0-dev-20260511080634",
+    "@powersync/service-sync-rules": "0.0.0-dev-20260511080634"
   },
   "devDependencies": {
-    "typescript": "^5.7.3",
-    "@powersync/service-core-tests": "0.0.0-dev-20260225160713"
+    "typescript": "~6.0.3",
+    "@powersync/service-core-tests": "0.0.0-dev-20260511080634"
   },
   "scripts": {
     "build": "tsc -b",
     "build:tests": "tsc -b test/tsconfig.json",
-    "clean": "rm -rf ./lib && tsc -b --clean",
+    "clean": "rm -rf ./dist && tsc -b --clean",
     "test": "vitest"
   }
 }

package/src/migrations/migration-utils.ts

@@ -1,9 +1,9 @@
 import * as lib_postgres from '@powersync/lib-service-postgres';
+import { ServiceAssertionError } from '@powersync/lib-services-framework';
 import { configFile } from '@powersync/service-types';
 import { isPostgresStorageConfig, normalizePostgresStorageConfig, PostgresStorageConfig } from '../types/types.js';
-import { STORAGE_SCHEMA_NAME } from '../utils/db.js';
-import { ServiceAssertionError } from '@powersync/lib-services-framework';
 import { getStorageApplicationName } from '../utils/application-name.js';
+import { STORAGE_SCHEMA_NAME } from '../utils/db.js';
 
 export const openMigrationDB = (config: configFile.BaseStorageConfig) => {
   if (!isPostgresStorageConfig(config)) {

package/src/migrations/scripts/1771424826685-current-data-pending-deletes.ts

@@ -0,0 +1,10 @@
+import { migrations } from '@powersync/service-core';
+
+export const up: migrations.PowerSyncMigrationFunction = async (_context) => {
+  // No-op.
+  // Pending-delete support is now storage-version specific and initialized when v3 sync config is deployed.
+};
+
+export const down: migrations.PowerSyncMigrationFunction = async (_context) => {
+  // No-op.
+};

package/src/storage/PostgresBucketStorageFactory.ts

@@ -1,4 +1,4 @@
-import { GetIntanceOptions, storage, SyncRulesBucketStorage } from '@powersync/service-core';
+import { framework, GetIntanceOptions, storage, SyncRulesBucketStorage } from '@powersync/service-core';
 import * as pg_wire from '@powersync/service-jpgwire';
 import crypto from 'crypto';
 import * as uuid from 'uuid';
@@ -6,11 +6,11 @@ import * as uuid from 'uuid';
 import * as lib_postgres from '@powersync/lib-service-postgres';
 import { models, NormalizedPostgresStorageConfig } from '../types/types.js';
 
+import { getStorageApplicationName } from '../utils/application-name.js';
 import { NOTIFICATION_CHANNEL, STORAGE_SCHEMA_NAME } from '../utils/db.js';
 import { notifySyncRulesUpdate } from './batch/PostgresBucketBatch.js';
 import { PostgresSyncRulesStorage } from './PostgresSyncRulesStorage.js';
 import { PostgresPersistedSyncRulesContent } from './sync-rules/PostgresPersistedSyncRulesContent.js';
-import { getStorageApplicationName } from '../utils/application-name.js';
 
 export type PostgresBucketStorageOptions = {
   config: NormalizedPostgresStorageConfig;
@@ -18,6 +18,7 @@ export type PostgresBucketStorageOptions = {
 };
 
 export class PostgresBucketStorageFactory extends storage.BucketStorageFactory {
+  [framework.DO_NOT_LOG] = true;
   readonly db: lib_postgres.DatabaseClient;
   public readonly slot_name_prefix: string;
 
@@ -82,15 +83,27 @@ export class PostgresBucketStorageFactory extends storage.BucketStorageFactory {
 
     const sizes = await this.db.sql`
       SELECT
-        pg_total_relation_size('current_data') AS current_size_bytes,
+        COALESCE(
+          pg_total_relation_size(to_regclass('current_data')),
+          0
+        ) AS v1_current_size_bytes,
+        COALESCE(
+          pg_total_relation_size(to_regclass('v3_current_data')),
+          0
+        ) AS v3_current_size_bytes,
         pg_total_relation_size('bucket_parameters') AS parameter_size_bytes,
         pg_total_relation_size('bucket_data') AS operations_size_bytes;
-    `.first<{ current_size_bytes: bigint; parameter_size_bytes: bigint; operations_size_bytes: bigint }>();
+    `.first<{
+      v1_current_size_bytes: bigint;
+      v3_current_size_bytes: bigint;
+      parameter_size_bytes: bigint;
+      operations_size_bytes: bigint;
+    }>();
 
     return {
       operations_size_bytes: Number(sizes!.operations_size_bytes),
       parameters_size_bytes: Number(sizes!.parameter_size_bytes),
-      replication_size_bytes: Number(sizes!.current_size_bytes)
+      replication_size_bytes: Number(sizes!.v1_current_size_bytes) + Number(sizes!.v3_current_size_bytes)
     };
   }
 
@@ -141,7 +154,16 @@ export class PostgresBucketStorageFactory extends storage.BucketStorageFactory {
   }
 
   async updateSyncRules(options: storage.UpdateSyncRulesOptions): Promise<PostgresPersistedSyncRulesContent> {
-    const storageVersion = options.storageVersion ?? storage.CURRENT_STORAGE_VERSION;
+    const storageVersion =
+      options.storageVersion ?? options.config.parsed.config.storageVersion ?? storage.CURRENT_STORAGE_VERSION;
+    const storageConfig = storage.STORAGE_VERSION_CONFIG[storageVersion];
+    if (storageConfig == null) {
+      throw new framework.ServiceError(
+        framework.ErrorCode.PSYNC_S1005,
+        `Unsupported storage version ${storageVersion}`
+      );
+    }
+    await this.initializeStorageVersion(storageConfig);
     return this.db.transaction(async (db) => {
       await db.sql`
         UPDATE sync_rules
@@ -202,14 +224,42 @@ export class PostgresBucketStorageFactory extends storage.BucketStorageFactory {
     });
   }
 
+  /**
+   * Lazy-initializes storage-version-specific structures, if needed.
+   */
+  private async initializeStorageVersion(storageConfig: storage.StorageVersionConfig) {
+    if (!storageConfig.softDeleteCurrentData) {
+      return;
+    }
+
+    await this.db.sql`
+      CREATE TABLE IF NOT EXISTS v3_current_data (
+        group_id integer NOT NULL,
+        source_table TEXT NOT NULL,
+        source_key bytea NOT NULL,
+        CONSTRAINT unique_v3_current_data_id PRIMARY KEY (group_id, source_table, source_key),
+        buckets jsonb NOT NULL,
+        data bytea NOT NULL,
+        lookups bytea[] NOT NULL,
+        pending_delete BIGINT NULL
+      )
+    `.execute();
+
+    await this.db.sql`
+      CREATE INDEX IF NOT EXISTS v3_current_data_pending_deletes ON v3_current_data (group_id, pending_delete)
+      WHERE
+        pending_delete IS NOT NULL
+    `.execute();
+  }
+
   async restartReplication(sync_rules_group_id: number): Promise<void> {
     const next = await this.getNextSyncRulesContent();
     const active = await this.getActiveSyncRulesContent();
 
-    // In both the below cases, we create a new sync rules instance.
+    // In both the below cases, we create a new replication stream.
     // The current one will continue serving sync requests until the next one has finished processing.
     if (next != null && next.id == sync_rules_group_id) {
-      // We need to redo the "next" sync rules
+      // We need to redo the "next" replication stream
 
       await this.updateSyncRules(next.asUpdateOptions());
       // Pro-actively stop replicating
@@ -222,7 +272,7 @@ export class PostgresBucketStorageFactory extends storage.BucketStorageFactory {
           AND state = ${{ value: storage.SyncRuleState.PROCESSING, type: 'varchar' }}
       `.execute();
     } else if (next == null && active?.id == sync_rules_group_id) {
-      // Slot removed for "active" sync rules, while there is no "next" one.
+      // Slot removed for "active" replication stream, while there is no "next" one.
       await this.updateSyncRules(active.asUpdateOptions());
 
       // Pro-actively stop replicating, but still serve clients with existing data
@@ -235,7 +285,7 @@ export class PostgresBucketStorageFactory extends storage.BucketStorageFactory {
           AND state = ${{ value: storage.SyncRuleState.ACTIVE, type: 'varchar' }}
       `.execute();
     } else if (next != null && active?.id == sync_rules_group_id) {
-      // Already have "next" sync rules - don't update any.
+      // Already have "next" replication stream - don't update any.
 
       // Pro-actively stop replicating, but still serve clients with existing data
       await this.db.sql`

package/src/storage/PostgresCompactor.ts

@@ -51,20 +51,20 @@ export class PostgresCompactor {
   private moveBatchLimit: number;
   private moveBatchQueryLimit: number;
   private clearBatchLimit: number;
-  private maxOpId: InternalOpId | undefined;
+  private maxOpId: InternalOpId;
   private buckets: string[] | undefined;
 
   constructor(
     private db: lib_postgres.DatabaseClient,
     private group_id: number,
-    options?: PostgresCompactOptions
+    options: PostgresCompactOptions
   ) {
-    this.idLimitBytes = (options?.memoryLimitMB ?? DEFAULT_MEMORY_LIMIT_MB) * 1024 * 1024;
-    this.moveBatchLimit = options?.moveBatchLimit ?? DEFAULT_MOVE_BATCH_LIMIT;
-    this.moveBatchQueryLimit = options?.moveBatchQueryLimit ?? DEFAULT_MOVE_BATCH_QUERY_LIMIT;
-    this.clearBatchLimit = options?.clearBatchLimit ?? DEFAULT_CLEAR_BATCH_LIMIT;
-    this.maxOpId = options?.maxOpId;
-    this.buckets = options?.compactBuckets;
+    this.idLimitBytes = (options.memoryLimitMB ?? DEFAULT_MEMORY_LIMIT_MB) * 1024 * 1024;
+    this.moveBatchLimit = options.moveBatchLimit ?? DEFAULT_MOVE_BATCH_LIMIT;
+    this.moveBatchQueryLimit = options.moveBatchQueryLimit ?? DEFAULT_MOVE_BATCH_QUERY_LIMIT;
+    this.clearBatchLimit = options.clearBatchLimit ?? DEFAULT_CLEAR_BATCH_LIMIT;
+    this.maxOpId = options.maxOpId ?? 0n;
+    this.buckets = options.compactBuckets;
   }
 
   /**
@@ -240,6 +240,15 @@ export class PostgresCompactor {
     }
   }
 
+  /**
+   * Expose the internal clearBucket() method to tests.
+   *
+   * @deprecated Only for tests
+   */
+  clearBucketForTests(bucket: string, op: InternalOpId) {
+    return this.clearBucket(bucket, op);
+  }
+
   /**
    * Perform a CLEAR compact for a bucket.
    *

package/src/storage/PostgresReportStorage.ts

@@ -1,15 +1,15 @@
+import * as lib_postgres from '@powersync/lib-service-postgres';
+import { logger } from '@powersync/lib-services-framework';
 import { storage } from '@powersync/service-core';
 import * as pg_wire from '@powersync/service-jpgwire';
 import { event_types } from '@powersync/service-types';
+import { ClientConnectionResponse } from '@powersync/service-types/dist/reports.js';
+import { toInteger } from 'ix/util/tointeger.js';
 import { v4 } from 'uuid';
-import * as lib_postgres from '@powersync/lib-service-postgres';
-import { NormalizedPostgresStorageConfig } from '../types/types.js';
 import { SdkReporting, SdkReportingDecoded } from '../types/models/SdkReporting.js';
-import { toInteger } from 'ix/util/tointeger.js';
-import { logger } from '@powersync/lib-services-framework';
+import { NormalizedPostgresStorageConfig } from '../types/types.js';
 import { getStorageApplicationName } from '../utils/application-name.js';
 import { STORAGE_SCHEMA_NAME } from '../utils/db.js';
-import { ClientConnectionResponse } from '@powersync/service-types/dist/reports.js';
 
 export type PostgresReportStorageOptions = {
   config: NormalizedPostgresStorageConfig;

package/src/storage/PostgresSyncRulesStorage.ts

@@ -9,11 +9,13 @@ import {
   internalToExternalOpId,
   LastValueSink,
   maxLsn,
+  ParameterSetLimitExceededError,
   PartialChecksum,
   PopulateChecksumCacheOptions,
   PopulateChecksumCacheResults,
   ReplicationCheckpoint,
   storage,
+  StorageVersionConfig,
   utils,
   WatchWriteCheckpointOptions
 } from '@powersync/service-core';
@@ -33,6 +35,7 @@ import { SourceTableDecoded, StoredRelationId } from '../types/models/SourceTabl
 import { pick } from '../utils/ts-codec.js';
 import { PostgresBucketBatch } from './batch/PostgresBucketBatch.js';
 import { PostgresWriteCheckpointAPI } from './checkpoints/PostgresWriteCheckpointAPI.js';
+import { PostgresCurrentDataStore } from './current-data-store.js';
 import { PostgresBucketStorageFactory } from './PostgresBucketStorageFactory.js';
 import { PostgresCompactor } from './PostgresCompactor.js';
 
@@ -48,15 +51,20 @@ export class PostgresSyncRulesStorage
   extends framework.BaseObserver<storage.SyncRulesBucketStorageListener>
   implements storage.SyncRulesBucketStorage
 {
+  [framework.DO_NOT_LOG] = true;
+
   public readonly group_id: number;
   public readonly sync_rules: storage.PersistedSyncRulesContent;
   public readonly slot_name: string;
   public readonly factory: PostgresBucketStorageFactory;
+  public readonly storageConfig: StorageVersionConfig;
+  public readonly logger: framework.Logger;
 
   private sharedIterator = new BroadcastIterable((signal) => this.watchActiveCheckpoint(signal));
 
   protected db: lib_postgres.DatabaseClient;
   protected writeCheckpointAPI: PostgresWriteCheckpointAPI;
+  private readonly currentDataStore: PostgresCurrentDataStore;
 
   //   TODO we might be able to share this in an abstract class
   private parsedSyncRulesCache:
@@ -71,6 +79,9 @@ export class PostgresSyncRulesStorage
     this.sync_rules = options.sync_rules;
     this.slot_name = options.sync_rules.slot_name;
     this.factory = options.factory;
+    this.storageConfig = options.sync_rules.getStorageConfig();
+    this.currentDataStore = new PostgresCurrentDataStore(this.storageConfig);
+    this.logger = options.sync_rules.logger;
 
     this.writeCheckpointAPI = new PostgresWriteCheckpointAPI({
       db: this.db,
@@ -100,8 +111,8 @@ export class PostgresSyncRulesStorage
   getParsedSyncRules(options: storage.ParseSyncRulesOptions): sync_rules.HydratedSyncRules {
     const { parsed, options: cachedOptions } = this.parsedSyncRulesCache ?? {};
     /**
-     * Check if the cached sync rules, if present, had the same options.
-     * Parse sync rules if the options are different or if there is no cached value.
+     * Check if the cached sync config, if present, had the same options.
+     * Parse sync config if the options are different or if there is no cached value.
      */
     if (!parsed || options.defaultSchema != cachedOptions?.defaultSchema) {
       this.parsedSyncRulesCache = { parsed: this.sync_rules.parsed(options).hydratedSyncRules(), options };
@@ -121,11 +132,22 @@ export class PostgresSyncRulesStorage
     `.execute();
   }
 
-  compact(options?: storage.CompactOptions): Promise<void> {
-    return new PostgresCompactor(this.db, this.group_id, options).compact();
+  async compact(options?: storage.CompactOptions): Promise<void> {
+    let maxOpId = options?.maxOpId;
+    if (maxOpId == null) {
+      const checkpoint = await this.getCheckpoint();
+      // Note: If there is no active checkpoint, this will be 0, in which case no compacting is performed
+      maxOpId = checkpoint.checkpoint;
+    }
+
+    return new PostgresCompactor(this.db, this.group_id, {
+      ...options,
+      maxOpId,
+      logger: this.logger
+    }).compact();
   }
 
-  async populatePersistentChecksumCache(options: PopulateChecksumCacheOptions): Promise<PopulateChecksumCacheResults> {
+  async populatePersistentChecksumCache(_options: PopulateChecksumCacheOptions): Promise<PopulateChecksumCacheResults> {
     // no-op - checksum cache is not implemented for Postgres yet
     return { buckets: 0 };
   }
@@ -327,10 +349,7 @@ export class PostgresSyncRulesStorage
     });
   }
 
-  async startBatch(
-    options: storage.StartBatchOptions,
-    callback: (batch: storage.BucketStorageBatch) => Promise<void>
-  ): Promise<storage.FlushedResult | null> {
+  async createWriter(options: storage.CreateWriterOptions): Promise<storage.BucketStorageBatch> {
     const syncRules = await this.db.sql`
       SELECT
         last_checkpoint_lsn,
@@ -347,78 +366,105 @@ export class PostgresSyncRulesStorage
 
     const checkpoint_lsn = syncRules?.last_checkpoint_lsn ?? null;
 
-    const batch = new PostgresBucketBatch({
-      logger: options.logger ?? framework.logger,
+    const writer = new PostgresBucketBatch({
+      logger: options.logger ?? this.logger,
       db: this.db,
       sync_rules: this.sync_rules.parsed(options).hydratedSyncRules(),
       group_id: this.group_id,
       slot_name: this.slot_name,
       last_checkpoint_lsn: checkpoint_lsn,
       keep_alive_op: syncRules?.keepalive_op,
-      no_checkpoint_before_lsn: syncRules?.no_checkpoint_before ?? options.zeroLSN,
       resumeFromLsn: maxLsn(syncRules?.snapshot_lsn, checkpoint_lsn),
       store_current_data: options.storeCurrentData,
       skip_existing_rows: options.skipExistingRows ?? false,
       batch_limits: this.options.batchLimits,
-      markRecordUnavailable: options.markRecordUnavailable
+      markRecordUnavailable: options.markRecordUnavailable,
+      storageConfig: this.storageConfig
     });
-    this.iterateListeners((cb) => cb.batchStarted?.(batch));
-
-    await callback(batch);
-    await batch.flush();
-    if (batch.last_flushed_op != null) {
-      return { flushed_op: batch.last_flushed_op };
-    } else {
-      return null;
-    }
+    this.iterateListeners((cb) => cb.batchStarted?.(writer));
+    return writer;
+  }
+
+  /**
+   * @deprecated Use `createWriter()` with `await using` instead.
+   */
+  async startBatch(
+    options: storage.CreateWriterOptions,
+    callback: (batch: storage.BucketStorageBatch) => Promise<void>
+  ): Promise<storage.FlushedResult | null> {
+    await using writer = await this.createWriter(options);
+    await callback(writer);
+    await writer.flush();
+    return writer.last_flushed_op != null ? { flushed_op: writer.last_flushed_op } : null;
   }
 
   async getParameterSets(
     checkpoint: ReplicationCheckpoint,
-    lookups: sync_rules.ScopedParameterLookup[]
+    lookups: sync_rules.ScopedParameterLookup[],
+    limit: number
   ): Promise<sync_rules.SqliteJsonRow[]> {
     const rows = await this.db.sql`
-      SELECT DISTINCT
-        ON (lookup, source_table, source_key) lookup,
-        source_table,
-        source_key,
-        id,
-        bucket_parameters
-      FROM
-        bucket_parameters
-      WHERE
-        group_id = ${{ type: 'int4', value: this.group_id }}
-        AND lookup = ANY (
-          SELECT
-            decode((FILTER ->> 0)::text, 'hex') -- Decode the hex string to bytea
+      WITH
+        rows AS (
+          SELECT DISTINCT
+            ON (lookup, source_table, source_key) lookup,
+            source_table,
+            source_key,
+            id,
+            bucket_parameters
           FROM
-            jsonb_array_elements(${{
+            bucket_parameters
+          WHERE
+            group_id = ${{ type: 'int4', value: this.group_id }}
+            AND lookup = ANY (
+              SELECT
+                decode((FILTER ->> 0)::text, 'hex') -- Decode the hex string to bytea
+              FROM
+                jsonb_array_elements(${{
         type: 'jsonb',
         value: lookups.map((l) => storage.serializeLookupBuffer(l).toString('hex'))
       }}) AS FILTER
+            )
+            AND id <= ${{ type: 'int8', value: checkpoint.checkpoint }}
+          ORDER BY
+            lookup,
+            source_table,
+            source_key,
+            id DESC
         )
-        AND id <= ${{ type: 'int8', value: checkpoint.checkpoint }}
-      ORDER BY
-        lookup,
-        source_table,
-        source_key,
-        id DESC
+      SELECT
+        bucket_parameters
+      FROM
+        rows
+      WHERE
+        bucket_parameters != '[]'
+      LIMIT
+        ${{ type: 'int4', value: limit + 1 }}
     `
       .decoded(pick(models.BucketParameters, ['bucket_parameters']))
       .rows();
 
-    const groupedParameters = rows.map((row) => {
-      return JSONBig.parse(row.bucket_parameters) as sync_rules.SqliteJsonRow;
-    });
-    return groupedParameters.flat();
+    const parameters = rows
+      .map((row) => {
+        return JSONBig.parse(row.bucket_parameters) as sync_rules.SqliteJsonRow[];
+      })
+      .flat();
+
+    if (parameters.length > limit) {
+      // Note that the LIMIT in the query allows more rows than parameters (because each row stores an array of
+      // parameter results). That array is very small though, and it doesn't allow fewer rows (due to the != []), so
+      // the SQL limit is good enough.
+      throw new ParameterSetLimitExceededError(limit);
+    }
+    return parameters;
   }
 
   async *getBucketDataBatch(
     checkpoint: InternalOpId,
-    dataBuckets: Map<string, InternalOpId>,
+    dataBuckets: storage.BucketDataRequest[],
     options?: storage.BucketDataBatchOptions
   ): AsyncIterable<storage.SyncBucketDataChunk> {
-    if (dataBuckets.size == 0) {
+    if (dataBuckets.length == 0) {
       return;
     }
 
@@ -430,10 +476,8 @@ export class PostgresSyncRulesStorage
     // not match up with chunks.
 
     const end = checkpoint ?? BIGINT_MAX;
-    const filters = Array.from(dataBuckets.entries()).map(([name, start]) => ({
-      bucket_name: name,
-      start: start
-    }));
+    const filters = dataBuckets.map((request) => ({ bucket_name: request.bucket, start: request.start }));
+    const startOpByBucket = new Map(dataBuckets.map((request) => [request.bucket, request.start]));
 
     const batchRowLimit = options?.limit ?? storage.DEFAULT_DOCUMENT_BATCH_LIMIT;
     const chunkSizeLimitBytes = options?.chunkLimitBytes ?? storage.DEFAULT_DOCUMENT_CHUNK_LIMIT_BYTES;
@@ -533,7 +577,7 @@ export class PostgresSyncRulesStorage
           }
 
           if (start == null) {
-            const startOpId = dataBuckets.get(bucket_name);
+            const startOpId = startOpByBucket.get(bucket_name);
             if (startOpId == null) {
               throw new framework.ServiceAssertionError(`data for unexpected bucket: ${bucket_name}`);
             }
@@ -588,7 +632,10 @@ export class PostgresSyncRulesStorage
     }
   }
 
-  async getChecksums(checkpoint: utils.InternalOpId, buckets: string[]): Promise<utils.ChecksumMap> {
+  async getChecksums(
+    checkpoint: utils.InternalOpId,
+    buckets: storage.BucketChecksumRequest[]
+  ): Promise<utils.ChecksumMap> {
     return this.checksumCache.getChecksumMap(checkpoint, buckets);
   }
 
@@ -626,7 +673,7 @@ export class PostgresSyncRulesStorage
       .first();
 
     if (syncRulesRow == null) {
-      throw new Error('Cannot find sync rules status');
+      throw new Error('Cannot find replication stream status');
     }
 
     return {
@@ -662,11 +709,7 @@ export class PostgresSyncRulesStorage
         group_id = ${{ type: 'int4', value: this.group_id }}
     `.execute();
 
-    await this.db.sql`
-      DELETE FROM current_data
-      WHERE
-        group_id = ${{ type: 'int4', value: this.group_id }}
-    `.execute();
+    await this.currentDataStore.deleteGroupRows(this.db, { groupId: this.group_id });
 
     await this.db.sql`
       DELETE FROM source_tables
@@ -823,7 +866,7 @@ export class PostgresSyncRulesStorage
 
     if (doc == null) {
       // Abort the connections - clients will have to retry later.
-      throw new framework.ServiceError(framework.ErrorCode.PSYNC_S2302, 'No active sync rules available');
+      throw new framework.ServiceError(framework.ErrorCode.PSYNC_S2302, 'No active replication stream available');
     }
 
     const sink = new LastValueSink<string>(undefined);
@@ -850,7 +893,7 @@ export class PostgresSyncRulesStorage
         continue;
       }
       if (Number(notification.active_checkpoint.id) != doc.id) {
-        // Active sync rules changed - abort and restart the stream
+        // Active replication stream changed - abort and restart the stream
         break;
       }
 
@@ -880,7 +923,7 @@ class PostgresReplicationCheckpoint implements storage.ReplicationCheckpoint {
     public readonly lsn: string | null
   ) {}
 
-  getParameterSets(lookups: sync_rules.ScopedParameterLookup[]): Promise<sync_rules.SqliteJsonRow[]> {
-    return this.storage.getParameterSets(this, lookups);
+  getParameterSets(lookups: sync_rules.ScopedParameterLookup[], limit: number): Promise<sync_rules.SqliteJsonRow[]> {
+    return this.storage.getParameterSets(this, lookups, limit);
   }
 }

package/src/storage/batch/OperationBatch.ts

@@ -5,6 +5,7 @@
 
 import { storage, utils } from '@powersync/service-core';
 import { RequiredOperationBatchLimits } from '../../types/types.js';
+import { postgresTableId } from '../table-id.js';
 
 /**
  * Batch of input operations.
@@ -89,13 +90,13 @@ export class RecordOperation {
 /**
  * In-memory cache key - must not be persisted.
  */
-export function cacheKey(sourceTableId: string, id: storage.ReplicaId) {
+export function cacheKey(sourceTableId: storage.SourceTableId, id: storage.ReplicaId) {
   return encodedCacheKey(sourceTableId, storage.serializeReplicaId(id));
 }
 
 /**
  * Calculates a cache key for a stored ReplicaId. This is usually stored as a bytea/Buffer.
  */
-export function encodedCacheKey(sourceTableId: string, storedKey: Buffer) {
-  return `${sourceTableId}.${storedKey.toString('base64')}`;
+export function encodedCacheKey(sourceTableId: storage.SourceTableId, storedKey: Buffer) {
+  return `${postgresTableId(sourceTableId)}.${storedKey.toString('base64')}`;
 }