@powersync/service-module-postgres-storage 0.11.2 → 0.13.0

package/dist/@types/migrations/scripts/1771232439485-storage-version.d.ts

@@ -0,0 +1,3 @@
+import { migrations } from '@powersync/service-core';
+export declare const up: migrations.PowerSyncMigrationFunction;
+export declare const down: migrations.PowerSyncMigrationFunction;

package/dist/@types/migrations/scripts/1771424826685-current-data-pending-deletes.d.ts

@@ -0,0 +1,3 @@
+import { migrations } from '@powersync/service-core';
+export declare const up: migrations.PowerSyncMigrationFunction;
+export declare const down: migrations.PowerSyncMigrationFunction;

package/dist/@types/migrations/scripts/1771491856000-sync-plan.d.ts

@@ -0,0 +1,3 @@
+import { migrations } from '@powersync/service-core';
+export declare const up: migrations.PowerSyncMigrationFunction;
+export declare const down: migrations.PowerSyncMigrationFunction;

package/dist/@types/storage/PostgresBucketStorageFactory.d.ts

@@ -1,5 +1,4 @@
-import * as framework from '@powersync/lib-services-framework';
-import { GetIntanceOptions, storage, SyncRulesBucketStorage, UpdateSyncRulesOptions } from '@powersync/service-core';
+import { GetIntanceOptions, storage, SyncRulesBucketStorage } from '@powersync/service-core';
 import * as pg_wire from '@powersync/service-jpgwire';
 import * as lib_postgres from '@powersync/lib-service-postgres';
 import { NormalizedPostgresStorageConfig } from '../types/types.js';
@@ -8,7 +7,7 @@ export type PostgresBucketStorageOptions = {
     config: NormalizedPostgresStorageConfig;
     slot_name_prefix: string;
 };
-export declare class PostgresBucketStorageFactory extends framework.BaseObserver<storage.BucketStorageFactoryListener> implements storage.BucketStorageFactory {
+export declare class PostgresBucketStorageFactory extends storage.BucketStorageFactory {
     protected options: PostgresBucketStorageOptions;
     readonly db: lib_postgres.DatabaseClient;
     readonly slot_name_prefix: string;
@@ -20,16 +19,13 @@ export declare class PostgresBucketStorageFactory extends framework.BaseObserver
     getStorageMetrics(): Promise<storage.StorageMetrics>;
     getPowerSyncInstanceId(): Promise<string>;
     getSystemIdentifier(): Promise<storage.BucketStorageSystemIdentifier>;
-    configureSyncRules(options: UpdateSyncRulesOptions): Promise<{
-        updated: boolean;
-        persisted_sync_rules?: storage.PersistedSyncRulesContent;
-        lock?: storage.ReplicationLock;
-    }>;
     updateSyncRules(options: storage.UpdateSyncRulesOptions): Promise<PostgresPersistedSyncRulesContent>;
+    /**
+     * Lazy-initializes storage-version-specific structures, if needed.
+     */
+    private initializeStorageVersion;
     restartReplication(sync_rules_group_id: number): Promise<void>;
-    getActiveSyncRules(options: storage.ParseSyncRulesOptions): Promise<storage.PersistedSyncRules | null>;
     getActiveSyncRulesContent(): Promise<storage.PersistedSyncRulesContent | null>;
-    getNextSyncRules(options: storage.ParseSyncRulesOptions): Promise<storage.PersistedSyncRules | null>;
     getNextSyncRulesContent(): Promise<storage.PersistedSyncRulesContent | null>;
     getReplicatingSyncRules(): Promise<storage.PersistedSyncRulesContent[]>;
     getStoppedSyncRules(): Promise<storage.PersistedSyncRulesContent[]>;

package/dist/@types/storage/PostgresCompactor.d.ts

@@ -1,5 +1,5 @@
 import * as lib_postgres from '@powersync/lib-service-postgres';
-import { storage } from '@powersync/service-core';
+import { InternalOpId, storage } from '@powersync/service-core';
 /**
  * Additional options, primarily for testing.
  */
@@ -15,15 +15,22 @@ export declare class PostgresCompactor {
     private clearBatchLimit;
     private maxOpId;
     private buckets;
-    constructor(db: lib_postgres.DatabaseClient, group_id: number, options?: PostgresCompactOptions);
+    constructor(db: lib_postgres.DatabaseClient, group_id: number, options: PostgresCompactOptions);
     /**
      * Compact buckets by converting operations into MOVE and/or CLEAR operations.
      *
      * See /docs/compacting-operations.md for details.
      */
     compact(): Promise<void>;
-    compactInternal(bucket: string | undefined): Promise<void>;
+    private compactAllBuckets;
+    private compactSingleBucket;
     private flush;
+    /**
+     * Expose the internal clearBucket() method to tests.
+     *
+     * @deprecated Only for tests
+     */
+    clearBucketForTests(bucket: string, op: InternalOpId): Promise<void>;
     /**
      * Perform a CLEAR compact for a bucket.
      *

package/dist/@types/storage/PostgresSyncRulesStorage.d.ts

@@ -1,5 +1,5 @@
 import * as lib_postgres from '@powersync/lib-service-postgres';
-import { CheckpointChanges, GetCheckpointChangesOptions, InternalOpId, PopulateChecksumCacheOptions, PopulateChecksumCacheResults, ReplicationCheckpoint, storage, utils, WatchWriteCheckpointOptions } from '@powersync/service-core';
+import { CheckpointChanges, GetCheckpointChangesOptions, InternalOpId, PopulateChecksumCacheOptions, PopulateChecksumCacheResults, ReplicationCheckpoint, storage, StorageVersionConfig, utils, WatchWriteCheckpointOptions } from '@powersync/service-core';
 import * as sync_rules from '@powersync/service-sync-rules';
 import { RequiredOperationBatchLimits } from '../types/types.js';
 import * as framework from '@powersync/lib-services-framework';
@@ -18,9 +18,11 @@ export declare class PostgresSyncRulesStorage extends framework.BaseObserver<sto
     readonly sync_rules: storage.PersistedSyncRulesContent;
     readonly slot_name: string;
     readonly factory: PostgresBucketStorageFactory;
+    readonly storageConfig: StorageVersionConfig;
     private sharedIterator;
     protected db: lib_postgres.DatabaseClient;
     protected writeCheckpointAPI: PostgresWriteCheckpointAPI;
+    private readonly currentDataStore;
     private parsedSyncRulesCache;
     private _checksumCache;
     constructor(options: PostgresSyncRulesStorageOptions);
@@ -42,8 +44,8 @@ export declare class PostgresSyncRulesStorage extends framework.BaseObserver<sto
     resolveTable(options: storage.ResolveTableOptions): Promise<storage.ResolveTableResult>;
     startBatch(options: storage.StartBatchOptions, callback: (batch: storage.BucketStorageBatch) => Promise<void>): Promise<storage.FlushedResult | null>;
     getParameterSets(checkpoint: ReplicationCheckpoint, lookups: sync_rules.ScopedParameterLookup[]): Promise<sync_rules.SqliteJsonRow[]>;
-    getBucketDataBatch(checkpoint: InternalOpId, dataBuckets: Map<string, InternalOpId>, options?: storage.BucketDataBatchOptions): AsyncIterable<storage.SyncBucketDataChunk>;
-    getChecksums(checkpoint: utils.InternalOpId, buckets: string[]): Promise<utils.ChecksumMap>;
+    getBucketDataBatch(checkpoint: InternalOpId, dataBuckets: storage.BucketDataRequest[], options?: storage.BucketDataBatchOptions): AsyncIterable<storage.SyncBucketDataChunk>;
+    getChecksums(checkpoint: utils.InternalOpId, buckets: storage.BucketChecksumRequest[]): Promise<utils.ChecksumMap>;
     clearChecksumCache(): void;
     terminate(options?: storage.TerminateOptions): Promise<void>;
     getStatus(): Promise<storage.SyncRuleStatus>;

package/dist/@types/storage/batch/OperationBatch.d.ts

@@ -40,8 +40,8 @@ export declare class RecordOperation {
 /**
  * In-memory cache key - must not be persisted.
  */
-export declare function cacheKey(sourceTableId: string, id: storage.ReplicaId): string;
+export declare function cacheKey(sourceTableId: storage.SourceTableId, id: storage.ReplicaId): string;
 /**
  * Calculates a cache key for a stored ReplicaId. This is usually stored as a bytea/Buffer.
  */
-export declare function encodedCacheKey(sourceTableId: string, storedKey: Buffer): string;
+export declare function encodedCacheKey(sourceTableId: storage.SourceTableId, storedKey: Buffer): string;

package/dist/@types/storage/batch/PostgresBucketBatch.d.ts

@@ -1,9 +1,9 @@
 import * as lib_postgres from '@powersync/lib-service-postgres';
 import { BaseObserver, Logger } from '@powersync/lib-services-framework';
-import { BucketStorageMarkRecordUnavailable, InternalOpId, storage } from '@powersync/service-core';
+import { BucketStorageMarkRecordUnavailable, CheckpointResult, InternalOpId, storage } from '@powersync/service-core';
 import * as sync_rules from '@powersync/service-sync-rules';
 import * as t from 'ts-codec';
-import { CurrentDataDecoded } from '../../types/models/CurrentData.js';
+import { V3CurrentDataDecoded } from '../../types/models/CurrentData.js';
 import { RequiredOperationBatchLimits } from '../../types/types.js';
 import { OperationBatch, RecordOperation } from './OperationBatch.js';
 import { PostgresPersistedBatch } from './PostgresPersistedBatch.js';
@@ -14,7 +14,6 @@ export interface PostgresBucketBatchOptions {
     group_id: number;
     slot_name: string;
     last_checkpoint_lsn: string | null;
-    no_checkpoint_before_lsn: string;
     store_current_data: boolean;
     keep_alive_op?: InternalOpId | null;
     resumeFromLsn: string | null;
@@ -24,6 +23,7 @@ export interface PostgresBucketBatchOptions {
     skip_existing_rows: boolean;
     batch_limits: RequiredOperationBatchLimits;
     markRecordUnavailable: BucketStorageMarkRecordUnavailable | undefined;
+    storageConfig: storage.StorageVersionConfig;
 }
 /**
  * Intermediate type which helps for only watching the active sync rules
@@ -49,7 +49,6 @@ export declare class PostgresBucketBatch extends BaseObserver<storage.BucketBatc
     protected db: lib_postgres.DatabaseClient;
     protected group_id: number;
     protected last_checkpoint_lsn: string | null;
-    protected no_checkpoint_before_lsn: string;
     protected persisted_op: InternalOpId | null;
     protected write_checkpoint_batch: storage.CustomWriteCheckpointOptions[];
     protected readonly sync_rules: sync_rules.HydratedSyncRules;
@@ -58,9 +57,10 @@ export declare class PostgresBucketBatch extends BaseObserver<storage.BucketBatc
     private markRecordUnavailable;
     private needsActivation;
     private clearedError;
+    private readonly storageConfig;
+    private readonly currentDataStore;
     constructor(options: PostgresBucketBatchOptions);
     get lastCheckpointLsn(): string | null;
-    get noCheckpointBeforeLsn(): string;
     [Symbol.asyncDispose](): Promise<void>;
     save(record: storage.SaveOptions): Promise<storage.FlushedResult | null>;
     truncate(sourceTables: storage.SourceTable[]): Promise<storage.FlushedResult | null>;
@@ -68,14 +68,16 @@ export declare class PostgresBucketBatch extends BaseObserver<storage.BucketBatc
     drop(sourceTables: storage.SourceTable[]): Promise<storage.FlushedResult | null>;
     flush(): Promise<storage.FlushedResult | null>;
     private flushInner;
-    commit(lsn: string, options?: storage.BucketBatchCommitOptions): Promise<boolean>;
-    keepalive(lsn: string): Promise<boolean>;
+    commit(lsn: string, options?: storage.BucketBatchCommitOptions): Promise<CheckpointResult>;
+    keepalive(lsn: string): Promise<CheckpointResult>;
     setResumeLsn(lsn: string): Promise<void>;
-    markSnapshotDone(tables: storage.SourceTable[], no_checkpoint_before_lsn: string): Promise<storage.SourceTable[]>;
+    markAllSnapshotDone(no_checkpoint_before_lsn: string): Promise<void>;
+    markTableSnapshotRequired(table: storage.SourceTable): Promise<void>;
+    markTableSnapshotDone(tables: storage.SourceTable[], no_checkpoint_before_lsn?: string): Promise<storage.SourceTable[]>;
     updateTableProgress(table: storage.SourceTable, progress: Partial<storage.TableSnapshotStatus>): Promise<storage.SourceTable>;
     addCustomWriteCheckpoint(checkpoint: storage.BatchedCustomWriteCheckpointOptions): void;
     protected replicateBatch(db: lib_postgres.WrappedConnection, batch: OperationBatch): Promise<OperationBatch | null>;
-    protected saveOperation(persistedBatch: PostgresPersistedBatch, operation: RecordOperation, currentData?: CurrentDataDecoded | null): Promise<{
+    protected saveOperation(persistedBatch: PostgresPersistedBatch, operation: RecordOperation, currentData?: V3CurrentDataDecoded | null): Promise<{
         group_id: number;
         source_table: string;
         source_key: Buffer<ArrayBuffer>;
@@ -86,6 +88,7 @@ export declare class PostgresBucketBatch extends BaseObserver<storage.BucketBatc
             table: string;
         }[];
         lookups: Buffer<ArrayBuffer>[];
+        pending_delete: bigint | null;
     } | null>;
     /**
      * Switch from processing -> active if relevant.

package/dist/@types/storage/batch/PostgresPersistedBatch.d.ts

@@ -18,7 +18,7 @@ export type SaveParameterDataOptions = {
     existing_lookups: Buffer[];
 };
 export type DeleteCurrentDataOptions = {
-    source_table_id: bigint;
+    source_table_id: string;
     /**
      * ReplicaID which needs to be serialized in order to be queried
      * or inserted into the DB
@@ -28,12 +28,19 @@ export type DeleteCurrentDataOptions = {
      * Optionally provide the serialized source key directly
      */
     serialized_source_key?: Buffer;
+    /**
+     * Streaming replication needs soft deletes, while truncating tables can use a hard delete directly.
+     */
+    soft: boolean;
 };
 export type PostgresPersistedBatchOptions = RequiredOperationBatchLimits & {
     group_id: number;
+    storageConfig: storage.StorageVersionConfig;
 };
 export declare class PostgresPersistedBatch {
     group_id: number;
+    private readonly storageConfig;
+    private readonly currentDataStore;
     /**
      * Very rough estimate of current operations size in bytes
      */
@@ -45,16 +52,21 @@ export declare class PostgresPersistedBatch {
      */
     protected bucketDataInserts: models.BucketData[];
     protected parameterDataInserts: models.BucketParameters[];
-    protected currentDataDeletes: Pick<models.CurrentData, 'group_id' | 'source_key' | 'source_table'>[];
     /**
-     * This is stored as a map to avoid multiple inserts (or conflicts) for the same key
+     * This is stored as a map to avoid multiple inserts (or conflicts) for the same key.
+     *
+     * Each key may only occur in one of these two maps.
      */
-    protected currentDataInserts: Map<string, models.CurrentData>;
+    protected currentDataInserts: Map<string, models.V3CurrentData>;
+    protected currentDataDeletes: Map<string, {
+        source_key_hex: string;
+        source_table: string;
+    }>;
     constructor(options: PostgresPersistedBatchOptions);
     saveBucketData(options: SaveBucketDataOptions): void;
     saveParameterData(options: SaveParameterDataOptions): void;
     deleteCurrentData(options: DeleteCurrentDataOptions): void;
-    upsertCurrentData(options: models.CurrentDataDecoded): void;
+    upsertCurrentData(options: models.V3CurrentDataDecoded, serialized_source_key?: Buffer): void;
     shouldFlushTransaction(): boolean;
     flush(db: lib_postgres.WrappedConnection): Promise<{
         flushedAny: boolean;

package/dist/@types/storage/current-data-store.d.ts

@@ -0,0 +1,85 @@
+import * as lib_postgres from '@powersync/lib-service-postgres';
+import { storage } from '@powersync/service-core';
+import * as t from 'ts-codec';
+import * as models from '../types/models/CurrentData.js';
+type Queryable = Pick<lib_postgres.DatabaseClient, 'sql' | 'streamRows'>;
+declare const TruncateCurrentDataCodec: t.ObjectCodec<Pick<{
+    buckets: t.Codec<{
+        id: string;
+        bucket: string;
+        table: string;
+    }[], string, string, t.CodecProps>;
+    data: t.Codec<Buffer<ArrayBuffer>, string, "hexBuffer", t.CodecProps>;
+    group_id: t.Codec<number, number, "pg_number", t.CodecProps>;
+    lookups: t.ArrayCodec<t.Codec<Buffer<ArrayBuffer>, string, "hexBuffer", t.CodecProps>>;
+    source_key: t.Codec<Buffer<ArrayBuffer>, string, "hexBuffer", t.CodecProps>;
+    source_table: t.IdentityCodec<t.CodecType.String>;
+}, "source_key" | "buckets" | "lookups">>;
+declare const LookupKeyCodec: t.ObjectCodec<Pick<{
+    buckets: t.Codec<{
+        id: string;
+        bucket: string;
+        table: string;
+    }[], string, string, t.CodecProps>;
+    data: t.Codec<Buffer<ArrayBuffer>, string, "hexBuffer", t.CodecProps>;
+    group_id: t.Codec<number, number, "pg_number", t.CodecProps>;
+    lookups: t.ArrayCodec<t.Codec<Buffer<ArrayBuffer>, string, "hexBuffer", t.CodecProps>>;
+    source_key: t.Codec<Buffer<ArrayBuffer>, string, "hexBuffer", t.CodecProps>;
+    source_table: t.IdentityCodec<t.CodecType.String>;
+}, "source_table" | "source_key">>;
+export type TruncateCurrentDataRow = t.Decoded<typeof TruncateCurrentDataCodec>;
+export type CurrentDataLookupRow = t.Decoded<typeof LookupKeyCodec> | t.Decoded<typeof models.V1CurrentData> | t.Decoded<typeof models.V3CurrentData>;
+export declare const V1_CURRENT_DATA_TABLE = "current_data";
+export declare const V3_CURRENT_DATA_TABLE = "v3_current_data";
+export declare class PostgresCurrentDataStore {
+    readonly table: string;
+    readonly softDeleteEnabled: boolean;
+    constructor(storageConfig: storage.StorageVersionConfig);
+    streamTruncateRows(db: Queryable, options: {
+        groupId: number;
+        sourceTableId: string;
+        limit: number;
+    }): AsyncIterableIterator<{
+        source_key: string;
+        buckets: string;
+        lookups: string[];
+    }[]>;
+    decodeTruncateRow(row: t.Encoded<typeof TruncateCurrentDataCodec>): TruncateCurrentDataRow;
+    streamSizeRows(db: Queryable, options: {
+        groupId: number;
+        lookups: {
+            source_table: string;
+            source_key: string;
+        }[];
+    }): AsyncIterableIterator<{
+        source_table: string;
+        source_key: storage.ReplicaId;
+        data_size: number;
+    }[]>;
+    streamLookupRows(db: Queryable, options: {
+        groupId: number;
+        lookups: {
+            source_table: string;
+            source_key: string;
+        }[];
+        skipExistingRows: boolean;
+    }): AsyncIterableIterator<any[]>;
+    decodeLookupRow(row: any, skipExistingRows: boolean): CurrentDataLookupRow;
+    flushUpserts(db: Queryable, updates: models.V3CurrentData[]): Promise<void>;
+    flushDeletes(db: Queryable, options: {
+        groupId: number;
+        deletes: {
+            source_key_hex: string;
+            source_table: string;
+        }[];
+    }): Promise<void>;
+    cleanupPendingDeletes(db: Queryable, options: {
+        groupId: number;
+        lastCheckpoint: bigint;
+    }): Promise<void>;
+    deleteGroupRows(db: Queryable, options: {
+        groupId: number;
+    }): Promise<void>;
+    private wherePendingDelete;
+}
+export {};

package/dist/@types/storage/current-data-table.d.ts

@@ -0,0 +1,9 @@
+import { storage } from '@powersync/service-core';
+export declare const V1_CURRENT_DATA_TABLE = "current_data";
+export declare const V3_CURRENT_DATA_TABLE = "v3_current_data";
+/**
+ * The table used by a specific storage version for general current_data access.
+ */
+export declare function getCommonCurrentDataTable(storageConfig: storage.StorageVersionConfig): "current_data" | "v3_current_data";
+export declare function getV1CurrentDataTable(storageConfig: storage.StorageVersionConfig): string;
+export declare function getV3CurrentDataTable(storageConfig: storage.StorageVersionConfig): string;

package/dist/@types/storage/sync-rules/PostgresPersistedSyncRulesContent.d.ts

@@ -1,18 +1,9 @@
 import * as lib_postgres from '@powersync/lib-service-postgres';
 import { storage } from '@powersync/service-core';
 import { models } from '../../types/types.js';
-export declare class PostgresPersistedSyncRulesContent implements storage.PersistedSyncRulesContent {
+export declare class PostgresPersistedSyncRulesContent extends storage.PersistedSyncRulesContent {
     private db;
-    readonly slot_name: string;
-    readonly id: number;
-    readonly sync_rules_content: string;
-    readonly last_checkpoint_lsn: string | null;
-    readonly last_fatal_error: string | null;
-    readonly last_keepalive_ts: Date | null;
-    readonly last_checkpoint_ts: Date | null;
-    readonly active: boolean;
     current_lock: storage.ReplicationLock | null;
     constructor(db: lib_postgres.DatabaseClient, row: models.SyncRulesDecoded);
-    parsed(options: storage.ParseSyncRulesOptions): storage.PersistedSyncRules;
     lock(): Promise<storage.ReplicationLock>;
 }

package/dist/@types/storage/table-id.d.ts

@@ -0,0 +1,2 @@
+import { storage } from '@powersync/service-core';
+export declare function postgresTableId(id: storage.SourceTableId): string;

package/dist/@types/types/models/CurrentData.d.ts

@@ -6,7 +6,7 @@ export declare const CurrentBucket: t.ObjectCodec<{
 }>;
 export type CurrentBucket = t.Encoded<typeof CurrentBucket>;
 export type CurrentBucketDecoded = t.Decoded<typeof CurrentBucket>;
-export declare const CurrentData: t.ObjectCodec<{
+export declare const V1CurrentData: t.ObjectCodec<{
     buckets: t.Codec<{
         id: string;
         bucket: string;
@@ -18,5 +18,20 @@ export declare const CurrentData: t.ObjectCodec<{
     source_key: t.Codec<Buffer<ArrayBuffer>, string, "hexBuffer", t.CodecProps>;
     source_table: t.IdentityCodec<t.CodecType.String>;
 }>;
-export type CurrentData = t.Encoded<typeof CurrentData>;
-export type CurrentDataDecoded = t.Decoded<typeof CurrentData>;
+export declare const V3CurrentData: t.ObjectCodec<{
+    buckets: t.Codec<{
+        id: string;
+        bucket: string;
+        table: string;
+    }[], string, string, t.CodecProps>;
+    data: t.Codec<Buffer<ArrayBuffer>, string, "hexBuffer", t.CodecProps>;
+    group_id: t.Codec<number, number, "pg_number", t.CodecProps>;
+    lookups: t.ArrayCodec<t.Codec<Buffer<ArrayBuffer>, string, "hexBuffer", t.CodecProps>>;
+    source_key: t.Codec<Buffer<ArrayBuffer>, string, "hexBuffer", t.CodecProps>;
+    source_table: t.IdentityCodec<t.CodecType.String>;
+    pending_delete: t.Union<t.Codec<null, null, string, t.CodecProps>, t.Codec<bigint, string | number, string, t.CodecProps>>;
+}>;
+export type V1CurrentData = t.Encoded<typeof V1CurrentData>;
+export type V1CurrentDataDecoded = t.Decoded<typeof V1CurrentData>;
+export type V3CurrentData = t.Encoded<typeof V3CurrentData>;
+export type V3CurrentDataDecoded = t.Decoded<typeof V3CurrentData>;

package/dist/@types/types/models/SyncRules.d.ts

@@ -33,19 +33,29 @@ export declare const SyncRules: t.ObjectCodec<{
      *
      * This may be old if no data is incoming.
      */
-    last_checkpoint_ts: t.Union<t.Codec<null, null, string, t.CodecProps>, t.Codec<Date, string | import("@powersync/service-sync-rules/src/index.js").DateTimeValue, string, t.CodecProps>>;
+    last_checkpoint_ts: t.Union<t.Codec<null, null, string, t.CodecProps>, t.Codec<Date, string | import("@powersync/service-sync-rules").DateTimeValue, string, t.CodecProps>>;
     /**
      * Last time we persisted a checkpoint or keepalive.
      *
      * This should stay fairly current while replicating.
      */
-    last_keepalive_ts: t.Union<t.Codec<null, null, string, t.CodecProps>, t.Codec<Date, string | import("@powersync/service-sync-rules/src/index.js").DateTimeValue, string, t.CodecProps>>;
+    last_keepalive_ts: t.Union<t.Codec<null, null, string, t.CodecProps>, t.Codec<Date, string | import("@powersync/service-sync-rules").DateTimeValue, string, t.CodecProps>>;
     /**
      * If an error is stopping replication, it will be stored here.
      */
     last_fatal_error: t.Union<t.Codec<null, null, string, t.CodecProps>, t.IdentityCodec<t.CodecType.String>>;
     keepalive_op: t.Union<t.Codec<null, null, string, t.CodecProps>, t.Codec<bigint, string | number, string, t.CodecProps>>;
+    storage_version: t.OptionalCodec<t.Codec<number | null, number | null, string, t.CodecProps>>;
     content: t.IdentityCodec<t.CodecType.String>;
+    sync_plan: t.Union<t.Codec<null, null, string, t.CodecProps>, t.Codec<{
+        plan: any;
+        compatibility: {
+            edition: number;
+            overrides: Record<string, boolean>;
+            maxTimeValuePrecision?: number | undefined;
+        };
+        eventDescriptors: Record<string, string[]>;
+    }, import("@powersync/service-jsonbig").JsonContainer>>;
 }>;
 export type SyncRules = t.Encoded<typeof SyncRules>;
 export type SyncRulesDecoded = t.Decoded<typeof SyncRules>;

package/dist/@types/types/models/json.d.ts

@@ -0,0 +1,11 @@
+import { JsonContainer } from '@powersync/service-jsonbig';
+import { Codec } from 'ts-codec';
+/**
+ * Wraps a codec to support {@link JsonContainer} values.
+ *
+ * Because our postgres client implementation wraps JSON objects in a {@link JsonContainer}, this intermediate layer is
+ * required to use JSON columns from Postgres in `ts-codec` models.
+ *
+ * Note that this serializes and deserializes values using {@link JSON}, so bigints are not supported.
+ */
+export declare function jsonContainerObject<I, O>(inner: Codec<I, O>): Codec<I, JsonContainer>;

package/dist/@types/types/types.d.ts

@@ -50,6 +50,7 @@ export declare const PostgresStorageConfig: t.Intersection<t.Codec<{
     reject_ip_ranges?: string[] | undefined;
     slot_name_prefix?: string | undefined;
     max_pool_size?: number | undefined;
+    connect_timeout?: number | undefined;
 }, {
     type: string;
     max_pool_size?: number | undefined;
@@ -71,6 +72,7 @@ export declare const PostgresStorageConfig: t.Intersection<t.Codec<{
     reject_ip_ranges?: string[] | undefined;
     slot_name_prefix?: string | undefined;
     max_pool_size?: number | undefined;
+    connect_timeout?: number | undefined;
 }, string, t.CodecProps>, t.ObjectCodec<{
     /**
      * Allow batch operation limits to be configurable.

package/dist/@types/utils/bson.d.ts

@@ -3,4 +3,4 @@ import { storage } from '@powersync/service-core';
  * BSON is used to serialize certain documents for storage in BYTEA columns.
  * JSONB columns do not directly support storing binary data which could be required in future.
  */
-export declare function replicaIdToSubkey(tableId: string, id: storage.ReplicaId): string;
+export declare function replicaIdToSubkey(tableId: storage.SourceTableId, id: storage.ReplicaId): string;

package/dist/@types/utils/db.d.ts

@@ -5,4 +5,13 @@ export declare const NOTIFICATION_CHANNEL = "powersynccheckpoints";
  * Re export for prettier to detect the tag better
  */
 export declare const sql: (strings: TemplateStringsArray, ...params: import("@powersync/service-jpgwire").StatementParam[]) => import("@powersync/service-jpgwire").Statement;
+/**
+ * Drop all Postgres storage tables used by the service, including migrations.
+ */
 export declare const dropTables: (client: lib_postgres.DatabaseClient) => Promise<void>;
+/**
+ * Clear all Postgres storage tables and reset sequences.
+ *
+ * Does not clear migration state.
+ */
+export declare const truncateTables: (db: lib_postgres.DatabaseClient) => Promise<void>;

package/dist/@types/utils/test-utils.d.ts

@@ -15,5 +15,5 @@ export declare function postgresTestSetup(factoryOptions: PostgresTestStorageOpt
     reportFactory: (options?: TestStorageOptions) => Promise<PostgresReportStorage>;
     factory: (options?: TestStorageOptions) => Promise<PostgresBucketStorageFactory>;
     migrate: (direction: framework.migrations.Direction) => Promise<void>;
+    tableIdStrings: boolean;
 };
-export declare function postgresTestStorageFactoryGenerator(factoryOptions: PostgresTestStorageOptions): (options?: TestStorageOptions) => Promise<PostgresBucketStorageFactory>;

package/dist/migrations/scripts/1771232439485-storage-version.js

@@ -0,0 +1,111 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { storage } from '@powersync/service-core';
+import { openMigrationDB } from '../migration-utils.js';
+export const up = async (context) => {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const { service_context: { configuration } } = context;
+        const client = __addDisposableResource(env_1, openMigrationDB(configuration.storage), true);
+        await client.transaction(async (db) => {
+            await db.sql `
+      ALTER TABLE sync_rules
+      ADD COLUMN storage_version integer NOT NULL DEFAULT 1
+    `.execute();
+        });
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        const result_1 = __disposeResources(env_1);
+        if (result_1)
+            await result_1;
+    }
+};
+export const down = async (context) => {
+    const env_2 = { stack: [], error: void 0, hasError: false };
+    try {
+        const { service_context: { configuration } } = context;
+        const client = __addDisposableResource(env_2, openMigrationDB(configuration.storage), true);
+        await client.transaction(async (db) => {
+            const newRules = await db.sql `
+      SELECT
+        id,
+        storage_version
+      FROM
+        sync_rules
+      WHERE
+        storage_version > ${{ type: 'int4', value: storage.LEGACY_STORAGE_VERSION }}
+    `.rows();
+            if (newRules.length > 0) {
+                throw new Error(`Cannot revert migration due to newer storage versions in use: ${newRules.map((r) => `${r.id}: v${r.storage_version}`).join(', ')}`);
+            }
+            await db.sql `
+      ALTER TABLE sync_rules
+      DROP COLUMN storage_version
+    `.execute();
+        });
+    }
+    catch (e_2) {
+        env_2.error = e_2;
+        env_2.hasError = true;
+    }
+    finally {
+        const result_2 = __disposeResources(env_2);
+        if (result_2)
+            await result_2;
+    }
+};
+//# sourceMappingURL=1771232439485-storage-version.js.map

package/dist/migrations/scripts/1771232439485-storage-version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"1771232439485-storage-version.js","sourceRoot":"","sources":["../../../src/migrations/scripts/1771232439485-storage-version.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,EAAc,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAExD,MAAM,CAAC,MAAM,EAAE,GAA0C,KAAK,EAAE,OAAO,EAAE,EAAE;;;QACzE,MAAM,EACJ,eAAe,EAAE,EAAE,aAAa,EAAE,EACnC,GAAG,OAAO,CAAC;QACZ,MAAY,MAAM,kCAAG,eAAe,CAAC,aAAa,CAAC,OAAO,CAAC,OAAA,CAAC;QAC5D,MAAM,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,EAAE,EAAE,EAAE;YACpC,MAAM,EAAE,CAAC,GAAG,CAAA;;;KAGX,CAAC,OAAO,EAAE,CAAC;QACd,CAAC,CAAC,CAAC;;;;;;;;;;;CACJ,CAAC;AAEF,MAAM,CAAC,MAAM,IAAI,GAA0C,KAAK,EAAE,OAAO,EAAE,EAAE;;;QAC3E,MAAM,EACJ,eAAe,EAAE,EAAE,aAAa,EAAE,EACnC,GAAG,OAAO,CAAC;QACZ,MAAY,MAAM,kCAAG,eAAe,CAAC,aAAa,CAAC,OAAO,CAAC,OAAA,CAAC;QAC5D,MAAM,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,EAAE,EAAE,EAAE;YACpC,MAAM,QAAQ,GAAG,MAAM,EAAE,CAAC,GAAG,CAAA;;;;;;;4BAOL,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,sBAAsB,EAAE;KAC9E,CAAC,IAAI,EAA6D,CAAC;YAEpE,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACxB,MAAM,IAAI,KAAK,CACb,iEAAiE,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,eAAe,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CACpI,CAAC;YACJ,CAAC;YAED,MAAM,EAAE,CAAC,GAAG,CAAA;;;KAGX,CAAC,OAAO,EAAE,CAAC;QACd,CAAC,CAAC,CAAC;;;;;;;;;;;CACJ,CAAC"}

package/dist/migrations/scripts/1771424826685-current-data-pending-deletes.js

@@ -0,0 +1,8 @@
+export const up = async (_context) => {
+    // No-op.
+    // Pending-delete support is now storage-version specific and initialized when v3 sync rules are deployed.
+};
+export const down = async (_context) => {
+    // No-op.
+};
+//# sourceMappingURL=1771424826685-current-data-pending-deletes.js.map

package/dist/migrations/scripts/1771424826685-current-data-pending-deletes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"1771424826685-current-data-pending-deletes.js","sourceRoot":"","sources":["../../../src/migrations/scripts/1771424826685-current-data-pending-deletes.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,EAAE,GAA0C,KAAK,EAAE,QAAQ,EAAE,EAAE;IAC1E,SAAS;IACT,0GAA0G;AAC5G,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,IAAI,GAA0C,KAAK,EAAE,QAAQ,EAAE,EAAE;IAC5E,SAAS;AACX,CAAC,CAAC"}