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

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/storage/PostgresBucketStorageFactory.d.ts

@@ -1,4 +1,4 @@
-import { GetIntanceOptions, storage, SyncRulesBucketStorage } from '@powersync/service-core';
+import { framework, GetIntanceOptions, storage, SyncRulesBucketStorage } from '@powersync/service-core';
 import * as pg_wire from '@powersync/service-jpgwire';
 import * as lib_postgres from '@powersync/lib-service-postgres';
 import { NormalizedPostgresStorageConfig } from '../types/types.js';
@@ -9,6 +9,7 @@ export type PostgresBucketStorageOptions = {
 };
 export declare class PostgresBucketStorageFactory extends storage.BucketStorageFactory {
     protected options: PostgresBucketStorageOptions;
+    [framework.DO_NOT_LOG]: boolean;
     readonly db: lib_postgres.DatabaseClient;
     readonly slot_name_prefix: string;
     private activeStorageCache;
@@ -20,6 +21,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

@@ -1,7 +1,7 @@
+import * as lib_postgres from '@powersync/lib-service-postgres';
 import { storage } from '@powersync/service-core';
 import * as pg_wire from '@powersync/service-jpgwire';
 import { event_types } from '@powersync/service-types';
-import * as lib_postgres from '@powersync/lib-service-postgres';
 import { NormalizedPostgresStorageConfig } from '../types/types.js';
 export type PostgresReportStorageOptions = {
     config: NormalizedPostgresStorageConfig;

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';
@@ -14,13 +14,17 @@ export type PostgresSyncRulesStorageOptions = {
 };
 export declare class PostgresSyncRulesStorage extends framework.BaseObserver<storage.SyncRulesBucketStorageListener> implements storage.SyncRulesBucketStorage {
     protected options: PostgresSyncRulesStorageOptions;
+    [framework.DO_NOT_LOG]: boolean;
     readonly group_id: number;
     readonly sync_rules: storage.PersistedSyncRulesContent;
     readonly slot_name: string;
     readonly factory: PostgresBucketStorageFactory;
+    readonly storageConfig: StorageVersionConfig;
+    readonly logger: framework.Logger;
     private sharedIterator;
     protected db: lib_postgres.DatabaseClient;
     protected writeCheckpointAPI: PostgresWriteCheckpointAPI;
+    private readonly currentDataStore;
     private parsedSyncRulesCache;
     private _checksumCache;
     constructor(options: PostgresSyncRulesStorageOptions);
@@ -34,16 +38,20 @@ export declare class PostgresSyncRulesStorage extends framework.BaseObserver<sto
     getParsedSyncRules(options: storage.ParseSyncRulesOptions): sync_rules.HydratedSyncRules;
     reportError(e: any): Promise<void>;
     compact(options?: storage.CompactOptions): Promise<void>;
-    populatePersistentChecksumCache(options: PopulateChecksumCacheOptions): Promise<PopulateChecksumCacheResults>;
+    populatePersistentChecksumCache(_options: PopulateChecksumCacheOptions): Promise<PopulateChecksumCacheResults>;
     lastWriteCheckpoint(filters: storage.SyncStorageLastWriteCheckpointFilters): Promise<bigint | null>;
     setWriteCheckpointMode(mode: storage.WriteCheckpointMode): void;
     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>;
-    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>;
+    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[], limit: number): Promise<sync_rules.SqliteJsonRow[]>;
+    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,9 +23,10 @@ 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
+ * Intermediate type which helps for only watching the active replication stream
  * via the Postgres NOTIFY protocol.
  */
 declare const StatefulCheckpoint: t.Intersection<t.Codec<{
@@ -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/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

@@ -55,6 +55,15 @@ export declare const SyncRules: t.ObjectCodec<{
             maxTimeValuePrecision?: number | undefined;
         };
         eventDescriptors: Record<string, string[]>;
+        errors?: {
+            level: "warning" | "fatal";
+            message: string;
+            location?: {
+                start_offset: number;
+                end_offset: number;
+            } | undefined;
+            ts?: string | undefined;
+        }[] | undefined;
     }, import("@powersync/service-jsonbig").JsonContainer>>;
 }>;
 export type SyncRules = t.Encoded<typeof SyncRules>;

package/dist/@types/types/models/models-index.d.ts

@@ -5,7 +5,7 @@ export * from './BucketParameters.js';
 export * from './CurrentData.js';
 export * from './Instance.js';
 export * from './Migration.js';
+export * from './SdkReporting.js';
 export * from './SourceTable.js';
 export * from './SyncRules.js';
 export * from './WriteCheckpoint.js';
-export * from './SdkReporting.js';

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

@@ -1,8 +1,8 @@
 import { framework, TestStorageOptions } from '@powersync/service-core';
 import { PostgresMigrationAgent } from '../migrations/PostgresMigrationAgent.js';
-import { PostgresStorageConfigDecoded } from '../types/types.js';
-import { PostgresReportStorage } from '../storage/PostgresReportStorage.js';
 import { PostgresBucketStorageFactory } from '../storage/PostgresBucketStorageFactory.js';
+import { PostgresReportStorage } from '../storage/PostgresReportStorage.js';
+import { PostgresStorageConfigDecoded } from '../types/types.js';
 export type PostgresTestStorageOptions = {
     url: string;
     /**
@@ -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/@types/utils/utils-index.d.ts

@@ -1,5 +1,5 @@
 export * from './bson.js';
 export * from './bucket-data.js';
 export * from './db.js';
-export * from './ts-codec.js';
 export * as test_utils from './test-utils.js';
+export * from './ts-codec.js';

package/dist/migrations/migration-utils.js

@@ -1,8 +1,8 @@
 import * as lib_postgres from '@powersync/lib-service-postgres';
-import { isPostgresStorageConfig, normalizePostgresStorageConfig, PostgresStorageConfig } from '../types/types.js';
-import { STORAGE_SCHEMA_NAME } from '../utils/db.js';
 import { ServiceAssertionError } from '@powersync/lib-services-framework';
+import { isPostgresStorageConfig, normalizePostgresStorageConfig, PostgresStorageConfig } from '../types/types.js';
 import { getStorageApplicationName } from '../utils/application-name.js';
+import { STORAGE_SCHEMA_NAME } from '../utils/db.js';
 export const openMigrationDB = (config) => {
     if (!isPostgresStorageConfig(config)) {
         throw new ServiceAssertionError(`Input storage configuration is not for Postgres`);

package/dist/migrations/migration-utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"migration-utils.js","sourceRoot":"","sources":["../../src/migrations/migration-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,YAAY,MAAM,iCAAiC,CAAC;AAEhE,OAAO,EAAE,uBAAuB,EAAE,8BAA8B,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AACnH,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,EAAE,qBAAqB,EAAE,MAAM,mCAAmC,CAAC;AAC1E,OAAO,EAAE,yBAAyB,EAAE,MAAM,8BAA8B,CAAC;AAEzE,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,MAAoC,EAAE,EAAE;IACtE,IAAI,CAAC,uBAAuB,CAAC,MAAM,CAAC,EAAE,CAAC;QACrC,MAAM,IAAI,qBAAqB,CAAC,iDAAiD,CAAC,CAAC;IACrF,CAAC;IACD,OAAO,IAAI,YAAY,CAAC,cAAc,CAAC;QACrC,MAAM,EAAE,8BAA8B,CAAC,qBAAqB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAC5E,MAAM,EAAE,mBAAmB;QAC3B,eAAe,EAAE,yBAAyB,EAAE;KAC7C,CAAC,CAAC;AACL,CAAC,CAAC"}
+{"version":3,"file":"migration-utils.js","sourceRoot":"","sources":["../../src/migrations/migration-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,YAAY,MAAM,iCAAiC,CAAC;AAChE,OAAO,EAAE,qBAAqB,EAAE,MAAM,mCAAmC,CAAC;AAE1E,OAAO,EAAE,uBAAuB,EAAE,8BAA8B,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AACnH,OAAO,EAAE,yBAAyB,EAAE,MAAM,8BAA8B,CAAC;AACzE,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAErD,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,MAAoC,EAAE,EAAE;IACtE,IAAI,CAAC,uBAAuB,CAAC,MAAM,CAAC,EAAE,CAAC;QACrC,MAAM,IAAI,qBAAqB,CAAC,iDAAiD,CAAC,CAAC;IACrF,CAAC;IACD,OAAO,IAAI,YAAY,CAAC,cAAc,CAAC;QACrC,MAAM,EAAE,8BAA8B,CAAC,qBAAqB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAC5E,MAAM,EAAE,mBAAmB;QAC3B,eAAe,EAAE,yBAAyB,EAAE;KAC7C,CAAC,CAAC;AACL,CAAC,CAAC"}