@powersync/service-module-postgres-storage 0.15.0 → 0.16.1

package/src/storage/PostgresSyncRulesStorage.ts

@@ -41,7 +41,7 @@ import { PostgresCompactor } from './PostgresCompactor.js';
 export type PostgresSyncRulesStorageOptions = {
   factory: PostgresBucketStorageFactory;
   db: lib_postgres.DatabaseClient;
-  sync_rules: storage.PersistedSyncRulesContent;
+  replicationStream: storage.PersistedReplicationStream;
   write_checkpoint_mode?: storage.WriteCheckpointMode;
   batchLimits: RequiredOperationBatchLimits;
 };
@@ -52,9 +52,10 @@ export class PostgresSyncRulesStorage
 {
   [framework.DO_NOT_LOG] = true;
 
-  public readonly group_id: number;
-  public readonly sync_rules: storage.PersistedSyncRulesContent;
-  public readonly slot_name: string;
+  public readonly replicationStreamId: number;
+  public readonly replicationStream: storage.PersistedReplicationStream;
+  public readonly sync_rules: storage.PersistedSyncConfigContent;
+  public readonly replicationStreamName: string;
   public readonly factory: PostgresBucketStorageFactory;
   public readonly storageConfig: StorageVersionConfig;
   public readonly logger: framework.Logger;
@@ -65,22 +66,27 @@ export class PostgresSyncRulesStorage
   protected writeCheckpointAPI: PostgresWriteCheckpointAPI;
   private readonly currentDataStore: PostgresCurrentDataStore;
 
-  //   TODO we might be able to share this in an abstract class
-  private parsedSyncRulesCache:
-    | { parsed: sync_rules.HydratedSyncConfig; options: storage.ParseSyncRulesOptions }
-    | undefined;
+  /**
+   * Canonical parsed sync config sets, keyed by defaultSchema. Entries are never evicted,
+   * so each parse options value maps to exactly one parsed set for the lifetime of this
+   * storage instance.
+   *
+   * TODO we might be able to share this in an abstract class
+   */
+  private readonly parsedSyncConfigSets = new Map<string, storage.ParsedSyncConfigSet>();
   private _checksumCache: storage.ChecksumCache | undefined;
 
   constructor(protected options: PostgresSyncRulesStorageOptions) {
     super();
-    this.group_id = options.sync_rules.id;
+    this.replicationStream = options.replicationStream;
+    this.replicationStreamId = options.replicationStream.replicationStreamId;
     this.db = options.db;
-    this.sync_rules = options.sync_rules;
-    this.slot_name = options.sync_rules.slot_name;
+    this.sync_rules = options.replicationStream.syncConfigContent[0];
+    this.replicationStreamName = options.replicationStream.replicationStreamName;
     this.factory = options.factory;
-    this.storageConfig = options.sync_rules.getStorageConfig();
+    this.storageConfig = options.replicationStream.getStorageConfig();
     this.currentDataStore = new PostgresCurrentDataStore(this.storageConfig);
-    this.logger = options.sync_rules.logger;
+    this.logger = options.replicationStream.logger;
 
     this.writeCheckpointAPI = new PostgresWriteCheckpointAPI({
       db: this.db,
@@ -106,18 +112,17 @@ export class PostgresSyncRulesStorage
     return this.writeCheckpointAPI.writeCheckpointMode;
   }
 
-  //   TODO we might be able to share this in an abstract class
-  getParsedSyncRules(options: storage.ParseSyncRulesOptions): sync_rules.HydratedSyncConfig {
-    const { parsed, options: cachedOptions } = this.parsedSyncRulesCache ?? {};
-    /**
-     * 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).hydratedSyncConfig(), options };
+  getParsedSyncConfigSet(options: storage.ParseSyncConfigOptions): storage.ParsedSyncConfigSet {
+    let parsed = this.parsedSyncConfigSets.get(options.defaultSchema);
+    if (parsed == null) {
+      parsed = this.replicationStream.parsed(options);
+      this.parsedSyncConfigSets.set(options.defaultSchema, parsed);
     }
+    return parsed;
+  }
 
-    return this.parsedSyncRulesCache!.parsed;
+  getParsedSyncRules(options: storage.ParseSyncConfigOptions): sync_rules.HydratedSyncConfig {
+    return this.getParsedSyncConfigSet(options).hydratedSyncConfig;
   }
 
   async reportError(e: any): Promise<void> {
@@ -127,7 +132,7 @@ export class PostgresSyncRulesStorage
       SET
         last_fatal_error = ${{ type: 'varchar', value: message }}
       WHERE
-        id = ${{ type: 'int4', value: this.group_id }};
+        id = ${{ type: 'int4', value: this.replicationStreamId }};
     `.execute();
   }
 
@@ -139,7 +144,7 @@ export class PostgresSyncRulesStorage
       maxOpId = checkpoint.checkpoint;
     }
 
-    return new PostgresCompactor(this.db, this.group_id, {
+    return new PostgresCompactor(this.db, this.replicationStreamId, {
       ...options,
       maxOpId,
       logger: this.logger
@@ -154,7 +159,7 @@ export class PostgresSyncRulesStorage
   lastWriteCheckpoint(filters: storage.SyncStorageLastWriteCheckpointFilters): Promise<bigint | null> {
     return this.writeCheckpointAPI.lastWriteCheckpoint({
       ...filters,
-      sync_rules_id: this.group_id
+      sync_rules_id: this.replicationStreamId
     });
   }
 
@@ -174,7 +179,7 @@ export class PostgresSyncRulesStorage
       FROM
         sync_rules
       WHERE
-        id = ${{ type: 'int4', value: this.group_id }}
+        id = ${{ type: 'int4', value: this.replicationStreamId }}
     `
       .decoded(pick(models.SyncRules, ['last_checkpoint', 'last_checkpoint_lsn']))
       .first();
@@ -196,7 +201,7 @@ export class PostgresSyncRulesStorage
       FROM
         sync_rules
       WHERE
-        id = ${{ type: 'int4', value: this.group_id }}
+        id = ${{ type: 'int4', value: this.replicationStreamId }}
     `
       .decoded(pick(models.SyncRules, ['last_checkpoint_lsn', 'no_checkpoint_before', 'keepalive_op', 'snapshot_lsn']))
       .first();
@@ -206,9 +211,9 @@ export class PostgresSyncRulesStorage
     const writer = new PostgresBucketBatch({
       logger: options.logger ?? this.logger,
       db: this.db,
-      sync_rules: this.sync_rules.parsed(options).hydratedSyncConfig(),
-      group_id: this.group_id,
-      slot_name: this.slot_name,
+      sync_rules: this.getParsedSyncRules(options),
+      replicationStreamId: this.replicationStreamId,
+      replicationStreamName: this.replicationStreamName,
       last_checkpoint_lsn: checkpoint_lsn,
       keep_alive_op: syncRules?.keepalive_op,
       resumeFromLsn: maxLsn(syncRules?.snapshot_lsn, checkpoint_lsn),
@@ -254,7 +259,7 @@ export class PostgresSyncRulesStorage
         value: lookups.map((l) => storage.serializeLookupBuffer(l).toString('hex'))
       }}) WITH ORDINALITY AS requested (value, index)
           WHERE
-            group_id = ${{ type: 'int4', value: this.group_id }}
+            group_id = ${{ type: 'int4', value: this.replicationStreamId }}
             AND lookup = decode((requested.value ->> 0)::text, 'hex') -- Decode the hex string to bytea
             AND id <= ${{ type: 'int8', value: checkpoint.checkpoint }}
           ORDER BY
@@ -381,7 +386,7 @@ export class PostgresSyncRulesStorage
           LIMIT
             $3;`,
       params: [
-        { type: 'int4', value: this.group_id },
+        { type: 'int4', value: this.replicationStreamId },
         { type: 'int8', value: end },
         { type: 'int4', value: batchRowLimit },
         ...filters.flatMap((f) => [
@@ -497,26 +502,23 @@ export class PostgresSyncRulesStorage
         state = ${{ type: 'varchar', value: storage.SyncRuleState.TERMINATED }},
         snapshot_done = ${{ type: 'bool', value: false }}
       WHERE
-        id = ${{ type: 'int4', value: this.group_id }}
+        id = ${{ type: 'int4', value: this.replicationStreamId }}
     `.execute();
   }
 
-  async getStatus(): Promise<storage.SyncRuleStatus> {
+  async getStatus(): Promise<storage.ReplicationStreamStatus> {
     const syncRulesRow = await this.db.sql`
       SELECT
         snapshot_done,
         snapshot_lsn,
         last_checkpoint_lsn,
-        state,
-        keepalive_op
+        state
       FROM
         sync_rules
       WHERE
-        id = ${{ type: 'int4', value: this.group_id }}
+        id = ${{ type: 'int4', value: this.replicationStreamId }}
     `
-      .decoded(
-        pick(models.SyncRules, ['snapshot_done', 'last_checkpoint_lsn', 'state', 'snapshot_lsn', 'keepalive_op'])
-      )
+      .decoded(pick(models.SyncRules, ['snapshot_done', 'last_checkpoint_lsn', 'snapshot_lsn']))
       .first();
 
     if (syncRulesRow == null) {
@@ -524,11 +526,8 @@ export class PostgresSyncRulesStorage
     }
 
     return {
-      snapshot_done: syncRulesRow.snapshot_done,
-      active: syncRulesRow.state == storage.SyncRuleState.ACTIVE,
-      checkpoint_lsn: syncRulesRow.last_checkpoint_lsn ?? null,
-      snapshot_lsn: syncRulesRow.snapshot_lsn ?? null,
-      keepalive_op: syncRulesRow.keepalive_op ?? null
+      snapshotDone: syncRulesRow.snapshot_done && syncRulesRow.last_checkpoint_lsn != null,
+      resumeLsn: maxLsn(syncRulesRow.snapshot_lsn, syncRulesRow.last_checkpoint_lsn)
     };
   }
 
@@ -542,27 +541,27 @@ export class PostgresSyncRulesStorage
         last_checkpoint = NULL,
         no_checkpoint_before = NULL
       WHERE
-        id = ${{ type: 'int4', value: this.group_id }}
+        id = ${{ type: 'int4', value: this.replicationStreamId }}
     `.execute();
 
     await this.db.sql`
       DELETE FROM bucket_data
       WHERE
-        group_id = ${{ type: 'int4', value: this.group_id }}
+        group_id = ${{ type: 'int4', value: this.replicationStreamId }}
     `.execute();
 
     await this.db.sql`
       DELETE FROM bucket_parameters
       WHERE
-        group_id = ${{ type: 'int4', value: this.group_id }}
+        group_id = ${{ type: 'int4', value: this.replicationStreamId }}
     `.execute();
 
-    await this.currentDataStore.deleteGroupRows(this.db, { groupId: this.group_id });
+    await this.currentDataStore.deleteGroupRows(this.db, { groupId: this.replicationStreamId });
 
     await this.db.sql`
       DELETE FROM source_tables
       WHERE
-        group_id = ${{ type: 'int4', value: this.group_id }}
+        group_id = ${{ type: 'int4', value: this.replicationStreamId }}
     `.execute();
   }
 
@@ -603,7 +602,7 @@ export class PostgresSyncRulesStorage
         AND b.op_id > f.start_op_id
         AND b.op_id <= f.end_op_id
       WHERE
-        b.group_id = ${{ type: 'int4', value: this.group_id }}
+        b.group_id = ${{ type: 'int4', value: this.replicationStreamId }}
       GROUP BY
         b.bucket_name;
     `.rows<{ bucket: string; checksum_total: bigint; total: bigint; has_clear_op: number }>();

package/src/storage/batch/PostgresBucketBatch.ts

@@ -38,8 +38,8 @@ export interface PostgresBucketBatchOptions {
   logger: Logger;
   db: lib_postgres.DatabaseClient;
   sync_rules: sync_rules.HydratedSyncConfig;
-  group_id: number;
-  slot_name: string;
+  replicationStreamId: number;
+  replicationStreamName: string;
   last_checkpoint_lsn: string | null;
   store_current_data: boolean;
   keep_alive_op?: InternalOpId | null;
@@ -112,7 +112,7 @@ export class PostgresBucketBatch
     super();
     this.logger = options.logger;
     this.db = options.db;
-    this.group_id = options.group_id;
+    this.group_id = options.replicationStreamId;
     this.last_checkpoint_lsn = options.last_checkpoint_lsn;
     this.resumeFromLsn = options.resumeFromLsn;
     this.skipExistingRows = options.skip_existing_rows;
@@ -129,10 +129,6 @@ export class PostgresBucketBatch
     }
   }
 
-  get lastCheckpointLsn() {
-    return this.last_checkpoint_lsn;
-  }
-
   async [Symbol.asyncDispose]() {
     if (this.batch != null || this.write_checkpoint_batch.length > 0) {
       // We don't error here, since:
@@ -148,7 +144,7 @@ export class PostgresBucketBatch
   }
 
   async resolveTables(options: storage.ResolveTablesOptions): Promise<storage.ResolveTablesResult> {
-    const syncRules = options.syncRules ?? this.sync_rules;
+    const syncRules = options.parsedSyncConfig?.hydratedSyncConfig ?? this.sync_rules;
     const { connection_id, source } = options;
     const { schema, name: table, objectId, replicaIdColumns, connectionTag, sendsCompleteRows } = source;
 
@@ -362,19 +358,22 @@ export class PostgresBucketBatch
     // TODO maybe share with abstract class
     const { after, before, sourceTable, tag } = record;
     const storeCurrentData = this.options.store_current_data && sourceTable.storeCurrentData;
-    for (const event of this.getTableEvents(sourceTable)) {
-      this.iterateListeners((cb) =>
-        cb.replicationEvent?.({
-          batch: this,
-          table: sourceTable,
-          data: {
-            op: tag,
-            after: after && utils.isCompleteRow(storeCurrentData, after) ? after : undefined,
-            before: before && utils.isCompleteRow(storeCurrentData, before) ? before : undefined
-          },
-          event
-        })
-      );
+    // Only the table designated as event carrier by resolveTables may fire events.
+    if (sourceTable.syncEvent) {
+      for (const event of this.getTableEvents(sourceTable)) {
+        this.iterateListeners((cb) =>
+          cb.replicationEvent?.({
+            batch: this,
+            table: sourceTable,
+            data: {
+              op: tag,
+              after: after && utils.isCompleteRow(storeCurrentData, after) ? after : undefined,
+              before: before && utils.isCompleteRow(storeCurrentData, before) ? before : undefined
+            },
+            event
+          })
+        );
+      }
     }
     /**
      * Return if the table is just an event table
@@ -761,23 +760,22 @@ export class PostgresBucketBatch
 
   async markSnapshotDone(no_checkpoint_before_lsn: string, options?: { throwOnConflict?: boolean }): Promise<void> {
     await this.db.transaction(async (db) => {
-      const snapshotRequiredCount = await db.sql`
+      const blockingTables = await db.sql`
         SELECT
-          COUNT(*) AS count
+          schema_name,
+          table_name
         FROM
           source_tables
         WHERE
           group_id = ${{ type: 'int4', value: this.group_id }}
           AND snapshot_done = FALSE
       `
-        .decoded(t.object({ count: bigint }))
-        .first();
-      if ((snapshotRequiredCount?.count ?? 0n) > 0n) {
+        .decoded(t.object({ schema_name: t.string, table_name: t.string }))
+        .rows();
+      if (blockingTables.length > 0) {
         if (options?.throwOnConflict ?? true) {
           throw new ReplicationAssertionError(
-            `Cannot mark snapshot done while ${snapshotRequiredCount?.count} source table${
-              snapshotRequiredCount?.count == 1n ? '' : 's'
-            } still require snapshotting`
+            `Cannot mark snapshot done while source tables still require snapshotting. Tables: ${blockingTables.map((t) => `${t.schema_name}.${t.table_name}`).join(', ')}`
           );
         } else {
           return;
@@ -1134,7 +1132,7 @@ export class PostgresBucketBatch
           {
             level: errors.ErrorSeverity.WARNING,
             metadata: {
-              replication_slot: this.options.slot_name,
+              replication_slot: this.options.replicationStreamName,
               table: record.sourceTable.qualifiedName
             }
           }
@@ -1190,7 +1188,7 @@ export class PostgresBucketBatch
             {
               level: errors.ErrorSeverity.WARNING,
               metadata: {
-                replication_slot: this.options.slot_name,
+                replication_slot: this.options.replicationStreamName,
                 table: record.sourceTable.qualifiedName
               }
             }
@@ -1231,7 +1229,7 @@ export class PostgresBucketBatch
             {
               level: errors.ErrorSeverity.WARNING,
               metadata: {
-                replication_slot: this.options.slot_name,
+                replication_slot: this.options.replicationStreamName,
                 table: record.sourceTable.qualifiedName
               }
             }

package/src/storage/storage-index.ts

@@ -1,4 +1,5 @@
 export * from './PostgresBucketStorageFactory.js';
 export * from './PostgresCompactor.js';
+export * from './PostgresReportStorage.js';
 export * from './PostgresStorageProvider.js';
 export * from './PostgresSyncRulesStorage.js';

package/src/storage/sync-rules/PostgresPersistedSyncConfigContent.ts

@@ -0,0 +1,98 @@
+import * as lib_postgres from '@powersync/lib-service-postgres';
+import { ErrorCode, ServiceError } from '@powersync/lib-services-framework';
+import { storage } from '@powersync/service-core';
+import { models } from '../../types/types.js';
+
+export class PostgresPersistedSyncConfigContent extends storage.PersistedSyncConfigContent {
+  constructor(
+    private db: lib_postgres.DatabaseClient,
+    row: models.SyncRulesDecoded
+  ) {
+    super({
+      replicationStreamId: Number(row.id),
+      sync_rules_content: row.content,
+      compiled_plan: row.sync_plan,
+      replicationStreamName: row.slot_name,
+      storageVersion: row.storage_version ?? storage.LEGACY_STORAGE_VERSION,
+      syncConfigState: row.state as storage.SyncRuleState
+    });
+  }
+
+  async getSyncConfigStatus(): Promise<storage.PersistedSyncConfigStatus | null> {
+    const row = await this.db.sql`
+      SELECT
+        *
+      FROM
+        sync_rules
+      WHERE
+        id = ${{ value: this.replicationStreamId, type: 'int4' }}
+    `
+      .decoded(models.SyncRules)
+      .first();
+
+    return row == null ? null : syncConfigStatusFromRow(row);
+  }
+}
+
+function syncConfigStatusFromRow(row: models.SyncRulesDecoded): storage.PersistedSyncConfigStatus {
+  return {
+    id: String(row.id),
+    replicationStreamId: Number(row.id),
+    state: row.state as storage.SyncRuleState,
+    snapshot_done: row.snapshot_done,
+    last_checkpoint_lsn: row.last_checkpoint_lsn,
+    last_fatal_error: row.last_fatal_error,
+    last_keepalive_ts: row.last_keepalive_ts ? new Date(row.last_keepalive_ts) : null,
+    last_checkpoint_ts: row.last_checkpoint_ts ? new Date(row.last_checkpoint_ts) : null
+  };
+}
+
+export class PostgresPersistedReplicationStream extends storage.PersistedReplicationStream {
+  current_lock: storage.ReplicationLock | null = null;
+  readonly syncConfigContent: readonly PostgresPersistedSyncConfigContent[];
+
+  constructor(
+    private db: lib_postgres.DatabaseClient,
+    private readonly row: models.SyncRulesDecoded
+  ) {
+    super({
+      replicationStreamId: Number(row.id),
+      replicationStreamName: row.slot_name,
+      state: row.state as storage.SyncRuleState,
+      storageVersion: row.storage_version ?? storage.LEGACY_STORAGE_VERSION
+    });
+    this.syncConfigContent = [new PostgresPersistedSyncConfigContent(this.db, this.row)];
+  }
+
+  parsed(options: storage.ParseSyncConfigOptions): storage.ParsedSyncConfigSet {
+    return this.syncConfigContent[0].parsed(options);
+  }
+
+  async lock(): Promise<storage.ReplicationLock> {
+    const manager = new lib_postgres.PostgresLockManager({
+      db: this.db,
+      name: `sync_rules_${this.replicationStreamId}_${this.replicationStreamName}`
+    });
+    const lockHandle = await manager.acquire();
+    if (!lockHandle) {
+      throw new ServiceError(ErrorCode.PSYNC_S1003, `Replication stream is locked by another process, standing by.`);
+    }
+
+    const interval = setInterval(async () => {
+      try {
+        await lockHandle.refresh();
+      } catch (e) {
+        this.logger.error('Failed to refresh lock', e);
+        clearInterval(interval);
+      }
+    }, 30_130);
+
+    return (this.current_lock = {
+      sync_rules_id: this.replicationStreamId,
+      release: async () => {
+        clearInterval(interval);
+        return lockHandle.release();
+      }
+    });
+  }
+}

package/src/utils/test-utils.ts

@@ -73,7 +73,7 @@ export function postgresTestSetup(factoryOptions: PostgresTestStorageOptions) {
 
     await using storageFactory = new PostgresBucketStorageFactory({
       config: TEST_CONNECTION_OPTIONS,
-      slot_name_prefix: 'test_'
+      replicationStreamNamePrefix: 'test_'
     });
     await truncateTables(storageFactory.db);
   };
@@ -102,7 +102,7 @@ export function postgresTestSetup(factoryOptions: PostgresTestStorageOptions) {
 
         return new PostgresBucketStorageFactory({
           config: TEST_CONNECTION_OPTIONS,
-          slot_name_prefix: 'test_'
+          replicationStreamNamePrefix: 'test_'
         });
       } catch (ex) {
         // Vitest does not display these errors nicely when using the `await using` syntx

package/test/src/migrations.test.ts

@@ -18,7 +18,7 @@ describe('Migrations', () => {
     const setup = POSTGRES_STORAGE_SETUP;
     await using factory = new PostgresBucketStorageFactory({
       config: TEST_CONNECTION_OPTIONS,
-      slot_name_prefix: 'test_'
+      replicationStreamNamePrefix: 'test_'
     });
 
     await dropTables(factory.db);

package/test/src/storage.test.ts

@@ -10,7 +10,11 @@ for (let storageVersion of TEST_STORAGE_VERSIONS) {
     register.registerDataStorageParameterTests({ ...POSTGRES_STORAGE_FACTORY, storageVersion }));
 
   describe(`Postgres Sync Bucket Storage - Data - v${storageVersion}`, () =>
-    register.registerDataStorageDataTests({ ...POSTGRES_STORAGE_FACTORY, storageVersion }));
+    register.registerDataStorageDataTests({
+      ...POSTGRES_STORAGE_FACTORY,
+      storageVersion,
+      compressedBucketStorage: false
+    }));
 
   describe(`Postgres Sync Bucket Storage - Checkpoints - v${storageVersion}`, () =>
     register.registerDataStorageCheckpointTests({ ...POSTGRES_STORAGE_FACTORY, storageVersion }));
@@ -39,7 +43,8 @@ for (let storageVersion of TEST_STORAGE_VERSIONS) {
         )
       );
       const bucketStorage = factory.getInstance(syncRules);
-      const globalBucket = bucketRequest(syncRules, 'global[]');
+      const syncRulesContent = syncRules.syncConfigContent[0];
+      const globalBucket = bucketRequest(syncRulesContent, 'global[]');
 
       const result = await (async () => {
         await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);

package/test/src/storage_compacting.test.ts

@@ -17,6 +17,7 @@ bucket_definitions:
       `)
     );
     const bucketStorage = factory.getInstance(syncRules);
+    const syncRulesContent = syncRules.syncConfigContent[0];
 
     const result = await (async () => {
       await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
@@ -44,12 +45,12 @@ bucket_definitions:
     // Compact with an explicit bucket name — exercises the this.buckets
     // iteration path, NOT the compactAllBuckets discovery path.
     await bucketStorage.compact({
-      compactBuckets: [bucketRequest(syncRules, 'global[]').bucket],
+      compactBuckets: [bucketRequest(syncRulesContent, 'global[]').bucket],
       minBucketChanges: 1
     });
 
     const batch = await test_utils.oneFromAsync(
-      bucketStorage.getBucketDataBatch(checkpoint, [bucketRequest(syncRules, 'global[]', 0n)])
+      bucketStorage.getBucketDataBatch(checkpoint, [bucketRequest(syncRulesContent, 'global[]', 0n)])
     );
 
     expect(batch.chunkData.data).toMatchObject([
@@ -70,7 +71,8 @@ bucket_definitions:
       `)
     );
     const bucketStorage = factory.getInstance(syncRules);
-    const request = bucketRequest(syncRules, 'global[]');
+    const syncRulesContent = syncRules.syncConfigContent[0];
+    const request = bucketRequest(syncRulesContent, 'global[]');
 
     const result = await (async () => {
       await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
@@ -110,7 +112,7 @@ bucket_definitions:
     const dataBefore = test_utils.getBatchData(rowsBefore);
     const clearToOpId = BigInt(dataBefore[2].op_id);
 
-    const compactor = new PostgresCompactor(factory.db, bucketStorage.group_id, {});
+    const compactor = new PostgresCompactor(factory.db, bucketStorage.replicationStreamId, {});
     // Trigger the private method directly
     await expect(compactor.clearBucketForTests(request.bucket, clearToOpId)).rejects.toThrow(
       /Unexpected PUT operation/

package/test/src/storage_sync.test.ts

@@ -34,7 +34,8 @@ function registerStorageVersionTests(storageVersion: number) {
         )
       );
       const bucketStorage = factory.getInstance(syncRules);
-      const globalBucket = bucketRequest(syncRules, 'global[]');
+      const syncRulesContent = syncRules.syncConfigContent[0];
+      const globalBucket = bucketRequest(syncRulesContent, 'global[]');
 
       await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
 

package/test/tsconfig.json

@@ -1,8 +1,6 @@
 {
   "extends": "../../../tsconfig.tests.json",
   "compilerOptions": {
-    "declarationDir": "dist/@types",
-    "tsBuildInfoFile": "dist/.tsbuildinfo",
     "lib": ["ES2022", "esnext.disposable"],
     "rootDir": "src"
   },

package/tsconfig.json

@@ -1,11 +1,8 @@
 {
   "extends": "../../tsconfig.base.json",
   "compilerOptions": {
-    "outDir": "dist",
-    "declarationDir": "dist/@types",
-    "tsBuildInfoFile": "dist/.tsbuildinfo",
     "rootDir": "src",
-    "skipLibCheck": true
+    "outDir": "dist"
   },
   "include": ["src"],
   "references": [