@powersync/service-module-postgres-storage 0.0.0-dev-20260225093637 → 0.0.0-dev-20260313100403

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

@@ -20,6 +20,10 @@ export declare class PostgresBucketStorageFactory extends storage.BucketStorageF
     getPowerSyncInstanceId(): Promise<string>;
     getSystemIdentifier(): Promise<storage.BucketStorageSystemIdentifier>;
     updateSyncRules(options: storage.UpdateSyncRulesOptions): Promise<PostgresPersistedSyncRulesContent>;
+    /**
+     * Lazy-initializes storage-version-specific structures, if needed.
+     */
+    private initializeStorageVersion;
     restartReplication(sync_rules_group_id: number): Promise<void>;
     getActiveSyncRulesContent(): Promise<storage.PersistedSyncRulesContent | null>;
     getNextSyncRulesContent(): Promise<storage.PersistedSyncRulesContent | null>;

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,7 +15,7 @@ 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.
      *
@@ -25,6 +25,12 @@ export declare class PostgresCompactor {
     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/PostgresReportStorage.d.ts

@@ -17,9 +17,9 @@ export declare class PostgresReportStorage implements storage.ReportStorage {
     private clientsConnectionPagination;
     reportClientConnection(data: event_types.ClientConnectionBucketData): Promise<void>;
     reportClientDisconnection(data: event_types.ClientDisconnectionEventData): Promise<void>;
-    getConnectedClients(): Promise<event_types.ClientConnectionReportResponse>;
-    getClientConnectionReports(data: event_types.ClientConnectionReportRequest): Promise<event_types.ClientConnectionReportResponse>;
-    getGeneralClientConnectionAnalytics(data: event_types.ClientConnectionAnalyticsRequest): Promise<event_types.PaginatedResponse<event_types.ClientConnection>>;
+    getCurrentConnections(): Promise<event_types.ClientConnectionReportResponse>;
+    getClientConnectionsSummary(data: event_types.ClientConnectionReportRequest): Promise<event_types.ClientConnectionReportResponse>;
+    getClientSessions(data: event_types.ClientConnectionAnalyticsRequest): Promise<event_types.PaginatedResponse<event_types.ClientConnection>>;
     deleteOldConnectionData(data: event_types.DeleteOldConnectionData): Promise<void>;
     [Symbol.asyncDispose](): Promise<void>;
     prepareStatements(connection: pg_wire.PgConnection): Promise<void>;

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);
@@ -40,10 +42,14 @@ export declare class PostgresSyncRulesStorage extends framework.BaseObserver<sto
     createManagedWriteCheckpoint(checkpoint: storage.ManagedWriteCheckpointOptions): Promise<bigint>;
     getCheckpoint(): Promise<storage.ReplicationCheckpoint>;
     resolveTable(options: storage.ResolveTableOptions): Promise<storage.ResolveTableResult>;
-    startBatch(options: storage.StartBatchOptions, callback: (batch: storage.BucketStorageBatch) => Promise<void>): Promise<storage.FlushedResult | null>;
+    createWriter(options: storage.CreateWriterOptions): Promise<storage.BucketStorageBatch>;
+    /**
+     * @deprecated Use `createWriter()` with `await using` instead.
+     */
+    startBatch(options: storage.CreateWriterOptions, 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,24 +57,28 @@ 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>;
+    dispose(): Promise<void>;
     save(record: storage.SaveOptions): Promise<storage.FlushedResult | null>;
     truncate(sourceTables: storage.SourceTable[]): Promise<storage.FlushedResult | null>;
     protected truncateSingle(sourceTable: storage.SourceTable): Promise<bigint | null>;
     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 +89,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/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

@@ -47,6 +47,15 @@ export declare const SyncRules: t.ObjectCodec<{
     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/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/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/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"}

package/dist/migrations/scripts/1771491856000-sync-plan.js

@@ -0,0 +1,91 @@
+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 { 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.sql `
+    ALTER TABLE sync_rules
+    ADD COLUMN sync_plan JSON;
+  `.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.sql `ALTER TABLE sync_rules DROP COLUMN sync_plan`.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=1771491856000-sync-plan.js.map

package/dist/migrations/scripts/1771491856000-sync-plan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"1771491856000-sync-plan.js","sourceRoot":"","sources":["../../../src/migrations/scripts/1771491856000-sync-plan.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,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,GAAG,CAAA;;;GAGf,CAAC,OAAO,EAAE,CAAC;;;;;;;;;;;CACb,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,GAAG,CAAA,8CAA8C,CAAC,OAAO,EAAE,CAAC;;;;;;;;;;;CAC1E,CAAC"}

package/dist/storage/PostgresBucketStorageFactory.js

@@ -1,13 +1,13 @@
-import { storage } from '@powersync/service-core';
+import { framework, storage } from '@powersync/service-core';
 import crypto from 'crypto';
 import * as uuid from 'uuid';
 import * as lib_postgres from '@powersync/lib-service-postgres';
 import { models } 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 class PostgresBucketStorageFactory extends storage.BucketStorageFactory {
     options;
     db;
@@ -64,14 +64,21 @@ 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();
         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)
         };
     }
     async getPowerSyncInstanceId() {
@@ -117,6 +124,11 @@ export class PostgresBucketStorageFactory extends storage.BucketStorageFactory {
     }
     async updateSyncRules(options) {
         const storageVersion = options.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
@@ -132,7 +144,14 @@ export class PostgresBucketStorageFactory extends storage.BucketStorageFactory {
               nextval('sync_rules_id_sequence') AS id
           )
         INSERT INTO
-          sync_rules (id, content, state, slot_name, storage_version)
+          sync_rules (
+            id,
+            content,
+            sync_plan,
+            state,
+            slot_name,
+            storage_version
+          )
         VALUES
           (
             (
@@ -142,6 +161,7 @@ export class PostgresBucketStorageFactory extends storage.BucketStorageFactory {
                 next_id
             ),
             ${{ type: 'varchar', value: options.config.yaml }},
+            ${{ type: 'json', value: options.config.plan }},
             ${{ type: 'varchar', value: storage.SyncRuleState.PROCESSING }},
             CONCAT(
               ${{ type: 'varchar', value: this.slot_name_prefix }},
@@ -165,6 +185,31 @@ export class PostgresBucketStorageFactory extends storage.BucketStorageFactory {
             return new PostgresPersistedSyncRulesContent(this.db, newSyncRulesRow);
         });
     }
+    /**
+     * Lazy-initializes storage-version-specific structures, if needed.
+     */
+    async initializeStorageVersion(storageConfig) {
+        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) {
         const next = await this.getNextSyncRulesContent();
         const active = await this.getActiveSyncRulesContent();