@powersync/service-module-postgres-storage 0.1.0

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

@@ -0,0 +1,42 @@
+import * as framework from '@powersync/lib-services-framework';
+import { storage } 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';
+import { PostgresPersistedSyncRulesContent } from './sync-rules/PostgresPersistedSyncRulesContent.js';
+export type PostgresBucketStorageOptions = {
+    config: NormalizedPostgresStorageConfig;
+    slot_name_prefix: string;
+};
+export declare class PostgresBucketStorageFactory extends framework.DisposableObserver<storage.BucketStorageFactoryListener> implements storage.BucketStorageFactory {
+    protected options: PostgresBucketStorageOptions;
+    readonly db: lib_postgres.DatabaseClient;
+    readonly slot_name_prefix: string;
+    private sharedIterator;
+    private readonly storageCache;
+    constructor(options: PostgresBucketStorageOptions);
+    [Symbol.asyncDispose](): Promise<void>;
+    prepareStatements(connection: pg_wire.PgConnection): Promise<void>;
+    getInstance(syncRules: storage.PersistedSyncRulesContent): storage.SyncRulesBucketStorage;
+    getStorageMetrics(): Promise<storage.StorageMetrics>;
+    getPowerSyncInstanceId(): Promise<string>;
+    configureSyncRules(sync_rules: string, options?: {
+        lock?: boolean;
+    }): Promise<{
+        updated: boolean;
+        persisted_sync_rules?: storage.PersistedSyncRulesContent;
+        lock?: storage.ReplicationLock;
+    }>;
+    updateSyncRules(options: storage.UpdateSyncRulesOptions): Promise<PostgresPersistedSyncRulesContent>;
+    slotRemoved(slot_name: string): 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[]>;
+    getActiveCheckpoint(): Promise<storage.ActiveCheckpoint>;
+    watchWriteCheckpoint(user_id: string, signal: AbortSignal): AsyncIterable<storage.WriteCheckpoint>;
+    protected watchActiveCheckpoint(signal: AbortSignal): AsyncIterable<storage.ActiveCheckpoint>;
+    private makeActiveCheckpoint;
+}

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

@@ -0,0 +1,40 @@
+import * as lib_postgres from '@powersync/lib-service-postgres';
+import { storage } from '@powersync/service-core';
+/**
+ * Additional options, primarily for testing.
+ */
+export interface PostgresCompactOptions extends storage.CompactOptions {
+    /** Minimum of 2 */
+    clearBatchLimit?: number;
+    /** Minimum of 1 */
+    moveBatchLimit?: number;
+    /** Minimum of 1 */
+    moveBatchQueryLimit?: number;
+}
+export declare class PostgresCompactor {
+    private db;
+    private group_id;
+    private updates;
+    private idLimitBytes;
+    private moveBatchLimit;
+    private moveBatchQueryLimit;
+    private clearBatchLimit;
+    private maxOpId;
+    private buckets;
+    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 flush;
+    /**
+     * Perform a CLEAR compact for a bucket.
+     *
+     * @param bucket bucket name
+     * @param op op_id of the last non-PUT operation, which will be converted to CLEAR.
+     */
+    private clearBucket;
+}

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

@@ -0,0 +1,5 @@
+import { storage } from '@powersync/service-core';
+export declare class PostgresStorageProvider implements storage.BucketStorageProvider {
+    get type(): "postgresql";
+    getStorage(options: storage.GetStorageOptions): Promise<storage.ActiveStorage>;
+}

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

@@ -0,0 +1,46 @@
+import * as lib_postgres from '@powersync/lib-service-postgres';
+import { DisposableObserver } from '@powersync/lib-services-framework';
+import { storage, utils } from '@powersync/service-core';
+import * as sync_rules from '@powersync/service-sync-rules';
+import { RequiredOperationBatchLimits } from '../types/types.js';
+import { PostgresWriteCheckpointAPI } from './checkpoints/PostgresWriteCheckpointAPI.js';
+import { PostgresBucketStorageFactory } from './PostgresBucketStorageFactory.js';
+export type PostgresSyncRulesStorageOptions = {
+    factory: PostgresBucketStorageFactory;
+    db: lib_postgres.DatabaseClient;
+    sync_rules: storage.PersistedSyncRulesContent;
+    write_checkpoint_mode?: storage.WriteCheckpointMode;
+    batchLimits: RequiredOperationBatchLimits;
+};
+export declare class PostgresSyncRulesStorage extends DisposableObserver<storage.SyncRulesBucketStorageListener> implements storage.SyncRulesBucketStorage {
+    protected options: PostgresSyncRulesStorageOptions;
+    readonly group_id: number;
+    readonly sync_rules: storage.PersistedSyncRulesContent;
+    readonly slot_name: string;
+    readonly factory: PostgresBucketStorageFactory;
+    protected db: lib_postgres.DatabaseClient;
+    protected writeCheckpointAPI: PostgresWriteCheckpointAPI;
+    private parsedSyncRulesCache;
+    private checksumCache;
+    constructor(options: PostgresSyncRulesStorageOptions);
+    get writeCheckpointMode(): storage.WriteCheckpointMode;
+    getParsedSyncRules(options: storage.ParseSyncRulesOptions): sync_rules.SqlSyncRules;
+    reportError(e: any): Promise<void>;
+    compact(options?: storage.CompactOptions): Promise<void>;
+    batchCreateCustomWriteCheckpoints(checkpoints: storage.BatchedCustomWriteCheckpointOptions[]): Promise<void>;
+    createCustomWriteCheckpoint(checkpoint: storage.BatchedCustomWriteCheckpointOptions): Promise<bigint>;
+    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: utils.OpId, lookups: sync_rules.SqliteJsonValue[][]): Promise<sync_rules.SqliteJsonRow[]>;
+    getBucketDataBatch(checkpoint: utils.OpId, dataBuckets: Map<string, string>, options?: storage.BucketDataBatchOptions): AsyncIterable<storage.SyncBucketDataBatch>;
+    getChecksums(checkpoint: utils.OpId, buckets: string[]): Promise<utils.ChecksumMap>;
+    terminate(options?: storage.TerminateOptions): Promise<void>;
+    getStatus(): Promise<storage.SyncRuleStatus>;
+    clear(): Promise<void>;
+    autoActivate(): Promise<void>;
+    private getChecksumsInternal;
+}

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

@@ -0,0 +1,13 @@
+import { TestStorageOptions } from '@powersync/service-core';
+import { PostgresMigrationAgent } from '../migrations/PostgresMigrationAgent.js';
+import { PostgresStorageConfigDecoded } from '../types/types.js';
+import { PostgresBucketStorageFactory } from './PostgresBucketStorageFactory.js';
+export type PostgresTestStorageOptions = {
+    url: string;
+    /**
+     * Vitest can cause issues when loading .ts files for migrations.
+     * This allows for providing a custom PostgresMigrationAgent.
+     */
+    migrationAgent?: (config: PostgresStorageConfigDecoded) => PostgresMigrationAgent;
+};
+export declare const PostgresTestStorageFactoryGenerator: (factoryOptions: PostgresTestStorageOptions) => (options?: TestStorageOptions) => Promise<PostgresBucketStorageFactory>;

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

@@ -0,0 +1,47 @@
+/**
+ * TODO share this implementation better in the core package.
+ * There are some subtle differences in this implementation.
+ */
+import { storage } from '@powersync/service-core';
+import { RequiredOperationBatchLimits } from '../../types/types.js';
+/**
+ * Batch of input operations.
+ *
+ * We accumulate operations up to MAX_RECORD_BATCH_SIZE,
+ * then further split into sub-batches if MAX_CURRENT_DATA_BATCH_SIZE is exceeded.
+ */
+export declare class OperationBatch {
+    protected options: RequiredOperationBatchLimits;
+    batch: RecordOperation[];
+    currentSize: number;
+    readonly maxBatchCount: number;
+    readonly maxRecordSize: number;
+    readonly maxCurrentDataBatchSize: number;
+    get length(): number;
+    constructor(options: RequiredOperationBatchLimits);
+    push(op: RecordOperation): void;
+    shouldFlush(): boolean;
+    /**
+     *
+     * @param sizes Map of source key to estimated size of the current_data document, or undefined if current_data is not persisted.
+     *
+     */
+    batched(sizes: Map<string, number> | undefined): Generator<RecordOperation[]>;
+}
+export declare class RecordOperation {
+    readonly record: storage.SaveOptions;
+    readonly afterId: storage.ReplicaId | null;
+    readonly beforeId: storage.ReplicaId;
+    readonly internalBeforeKey: string;
+    readonly internalAfterKey: string | null;
+    readonly estimatedSize: number;
+    constructor(record: storage.SaveOptions);
+}
+/**
+ * In-memory cache key - must not be persisted.
+ */
+export declare function cacheKey(sourceTableId: string, 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;

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

@@ -0,0 +1,90 @@
+import * as lib_postgres from '@powersync/lib-service-postgres';
+import { DisposableObserver } from '@powersync/lib-services-framework';
+import { 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 { RequiredOperationBatchLimits } from '../../types/types.js';
+import { OperationBatch, RecordOperation } from './OperationBatch.js';
+import { PostgresPersistedBatch } from './PostgresPersistedBatch.js';
+export interface PostgresBucketBatchOptions {
+    db: lib_postgres.DatabaseClient;
+    sync_rules: sync_rules.SqlSyncRules;
+    group_id: number;
+    slot_name: string;
+    last_checkpoint_lsn: string | null;
+    no_checkpoint_before_lsn: string;
+    store_current_data: boolean;
+    keep_alive_op?: bigint | null;
+    /**
+     * Set to true for initial replication.
+     */
+    skip_existing_rows: boolean;
+    batch_limits: RequiredOperationBatchLimits;
+}
+/**
+ * Intermediate type which helps for only watching the active sync rules
+ * via the Postgres NOTIFY protocol.
+ */
+declare const StatefulCheckpoint: t.Intersection<t.Codec<{
+    id: number;
+    last_checkpoint: bigint | null;
+    last_checkpoint_lsn: string | null;
+}, {
+    id: number;
+    last_checkpoint: string | number | null;
+    last_checkpoint_lsn: string | null;
+}, string, t.CodecProps>, t.ObjectCodec<{
+    state: t.EnumCodec<typeof storage.SyncRuleState>;
+}>>;
+type StatefulCheckpointDecoded = t.Decoded<typeof StatefulCheckpoint>;
+export declare class PostgresBucketBatch extends DisposableObserver<storage.BucketBatchStorageListener> implements storage.BucketStorageBatch {
+    protected options: PostgresBucketBatchOptions;
+    last_flushed_op: bigint | null;
+    protected db: lib_postgres.DatabaseClient;
+    protected group_id: number;
+    protected last_checkpoint_lsn: string | null;
+    protected no_checkpoint_before_lsn: string;
+    protected persisted_op: bigint | null;
+    protected write_checkpoint_batch: storage.CustomWriteCheckpointOptions[];
+    protected readonly sync_rules: sync_rules.SqlSyncRules;
+    protected batch: OperationBatch | null;
+    private lastWaitingLogThrottled;
+    constructor(options: PostgresBucketBatchOptions);
+    get lastCheckpointLsn(): string | null;
+    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): Promise<boolean>;
+    keepalive(lsn: string): Promise<boolean>;
+    markSnapshotDone(tables: storage.SourceTable[], no_checkpoint_before_lsn: string): 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<{
+        group_id: number;
+        source_table: string;
+        source_key: Buffer;
+        data: Buffer;
+        buckets: {
+            id: string;
+            bucket: string;
+            table: string;
+        }[];
+        lookups: Buffer[];
+    } | null>;
+    /**
+     * Gets relevant {@link SqlEventDescriptor}s for the given {@link SourceTable}
+     * TODO maybe share this with an abstract class
+     */
+    protected getTableEvents(table: storage.SourceTable): sync_rules.SqlEventDescriptor[];
+    protected withReplicationTransaction<T>(callback: (tx: lib_postgres.WrappedConnection) => Promise<T>): Promise<T>;
+}
+/**
+ * Uses Postgres' NOTIFY functionality to update different processes when the
+ * active checkpoint has been updated.
+ */
+export declare const notifySyncRulesUpdate: (db: lib_postgres.DatabaseClient, update: StatefulCheckpointDecoded) => Promise<void>;
+export {};

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

@@ -0,0 +1,64 @@
+import * as lib_postgres from '@powersync/lib-service-postgres';
+import { storage } from '@powersync/service-core';
+import * as sync_rules from '@powersync/service-sync-rules';
+import { models, RequiredOperationBatchLimits } from '../../types/types.js';
+export type SaveBucketDataOptions = {
+    /**
+     * This value will be serialized into a BSON Byte array for storage
+     */
+    source_key: storage.ReplicaId;
+    table: storage.SourceTable;
+    before_buckets: models.CurrentBucket[];
+    evaluated: sync_rules.EvaluatedRow[];
+};
+export type SaveParameterDataOptions = {
+    source_key: storage.ReplicaId;
+    table: storage.SourceTable;
+    evaluated: sync_rules.EvaluatedParameters[];
+    existing_lookups: Buffer[];
+};
+export type DeleteCurrentDataOptions = {
+    source_table_id: bigint;
+    /**
+     * ReplicaID which needs to be serialized in order to be queried
+     * or inserted into the DB
+     */
+    source_key?: storage.ReplicaId;
+    /**
+     * Optionally provide the serialized source key directly
+     */
+    serialized_source_key?: Buffer;
+};
+export type PostgresPersistedBatchOptions = RequiredOperationBatchLimits & {
+    group_id: number;
+};
+export declare class PostgresPersistedBatch {
+    group_id: number;
+    /**
+     * Very rough estimate of current operations size in bytes
+     */
+    currentSize: number;
+    readonly maxTransactionBatchSize: number;
+    readonly maxTransactionDocCount: number;
+    /**
+     * Ordered set of bucket_data insert operation parameters
+     */
+    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
+     */
+    protected currentDataInserts: Map<string, models.CurrentData>;
+    constructor(options: PostgresPersistedBatchOptions);
+    saveBucketData(options: SaveBucketDataOptions): void;
+    saveParameterData(options: SaveParameterDataOptions): void;
+    deleteCurrentData(options: DeleteCurrentDataOptions): void;
+    upsertCurrentData(options: models.CurrentDataDecoded): void;
+    shouldFlushTransaction(): boolean;
+    flush(db: lib_postgres.WrappedConnection): Promise<void>;
+    protected flushBucketData(db: lib_postgres.WrappedConnection): Promise<void>;
+    protected flushParameterData(db: lib_postgres.WrappedConnection): Promise<void>;
+    protected flushCurrentData(db: lib_postgres.WrappedConnection): Promise<void>;
+}
+export declare function currentBucketKey(b: models.CurrentBucket): string;

package/dist/@types/storage/checkpoints/PostgresWriteCheckpointAPI.d.ts

@@ -0,0 +1,20 @@
+import * as lib_postgres from '@powersync/lib-service-postgres';
+import { storage } from '@powersync/service-core';
+export type PostgresCheckpointAPIOptions = {
+    db: lib_postgres.DatabaseClient;
+    mode: storage.WriteCheckpointMode;
+};
+export declare class PostgresWriteCheckpointAPI implements storage.WriteCheckpointAPI {
+    readonly db: lib_postgres.DatabaseClient;
+    private _mode;
+    constructor(options: PostgresCheckpointAPIOptions);
+    get writeCheckpointMode(): storage.WriteCheckpointMode;
+    setWriteCheckpointMode(mode: storage.WriteCheckpointMode): void;
+    batchCreateCustomWriteCheckpoints(checkpoints: storage.CustomWriteCheckpointOptions[]): Promise<void>;
+    createCustomWriteCheckpoint(options: storage.CustomWriteCheckpointOptions): Promise<bigint>;
+    createManagedWriteCheckpoint(checkpoint: storage.ManagedWriteCheckpointOptions): Promise<bigint>;
+    lastWriteCheckpoint(filters: storage.LastWriteCheckpointFilters): Promise<bigint | null>;
+    protected lastCustomWriteCheckpoint(filters: storage.CustomWriteCheckpointFilters): Promise<bigint | null>;
+    protected lastManagedWriteCheckpoint(filters: storage.ManagedWriteCheckpointFilters): Promise<bigint | null>;
+}
+export declare function batchCreateCustomWriteCheckpoints(db: lib_postgres.DatabaseClient, checkpoints: storage.CustomWriteCheckpointOptions[]): Promise<void>;

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

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

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

@@ -0,0 +1,17 @@
+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 {
+    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;
+    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/types/codecs.d.ts

@@ -0,0 +1,61 @@
+import * as t from 'ts-codec';
+export declare const BIGINT_MAX: bigint;
+/**
+ * The use of ts-codec:
+ * We currently use pgwire for Postgres queries. This library provides fine-grained control
+ * over parameter typings and efficient streaming of query responses. Additionally, configuring
+ * pgwire with default certificates allows us to use the same connection configuration process
+ * for both replication and storage libraries.
+ *
+ * Unfortunately, ORM driver support for pgwire is limited, so we rely on pure SQL queries in the
+ * absence of writing an ORM driver from scratch.
+ *
+ * [Opinion]: Writing pure SQL queries throughout a codebase can be daunting from a maintenance
+ * and debugging perspective. For example, row response types are often declared when performing a query:
+ *
+ * ```typescript
+ * const rows = await db.queryRows<MyRowType>(`SELECT one, two FROM my_table`);
+ * ```
+ * This type declaration suggests `rows` is an array of `MyRowType` objects, even though no validation
+ * is enforced. Adding a field to the `MyRowType` interface without updating the query could easily
+ * introduce subtle bugs. Similarly, type mismatches between SQL results and TypeScript interfaces, such as
+ * a `Date` field returned as a `string`, require manual conversion.
+ *
+ * `ts-codec` is not an ORM, but it simplifies working with pure SQL query responses in several ways:
+ *
+ * - **Validations**: The `decode` operation ensures that the returned row matches the expected object
+ *   structure, throwing an error if it doesn't.
+ * - **Decoding Columns**: pgwire already decodes common SQLite types, but `ts-codec` adds an extra layer
+ *   for JS-native values. For instance, `jsonb` columns are returned as `JsonContainer`/`string` and can
+ *   be automatically parsed into objects. Similarly, fields like `group_id` are converted from `Bigint`
+ *   to `Number` for easier use.
+ * - **Encoded Forms**: A single `ts-codec` type definition can infer both encoded and decoded forms. This
+ *   is especially useful for persisted batch operations that rely on JSON query parameters for bulk inserts.
+ *   Collections like `bucket_data`, `current_data`, and `bucket_parameters` use encoded/decoded types, making
+ *   changes easier to manage and validate. While some manual encoding is done for intermediate values (e.g.,
+ *   size estimation), these types are validated with `ts-codec` to ensure consistency.
+ */
+/**
+ * Wraps a codec which is encoded to a JSON string
+ */
+export declare const jsonb: <Decoded>(subCodec: t.Codec<Decoded, any>) => t.Codec<Decoded, string, string, t.CodecProps>;
+/**
+ * Just performs a pure JSON.parse for the decoding step
+ */
+export declare const jsonb_raw: <Decoded>() => t.Codec<Decoded, string, string, t.CodecProps>;
+export declare const bigint: t.Codec<bigint, string | number, string, t.CodecProps>;
+export declare const uint8array: t.Codec<Uint8Array, Uint8Array, string, t.CodecProps>;
+/**
+ * PGWire returns BYTEA values as Uint8Array instances.
+ * We also serialize to a hex string for bulk inserts.
+ */
+export declare const hexBuffer: t.Codec<Buffer, string, "hexBuffer", t.CodecProps>;
+/**
+ * PGWire returns INTEGER columns as a `bigint`.
+ * This does a decode operation to `number`.
+ */
+export declare const pgwire_number: t.Codec<number, number, "pg_number", t.CodecProps>;
+/**
+ * A codec which contains the same type on the input and output.
+ */
+export declare const IdentityCodec: <T>() => t.Codec<T, T, string, t.CodecProps>;

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

@@ -0,0 +1,12 @@
+import * as t from 'ts-codec';
+/**
+ * Notification payload sent via Postgres' NOTIFY API.
+ *
+ */
+export declare const ActiveCheckpoint: t.ObjectCodec<{
+    id: t.Codec<number, number, "pg_number", t.CodecProps>;
+    last_checkpoint: t.Union<t.Codec<null, null, string, t.CodecProps>, t.Codec<bigint, string | number, string, t.CodecProps>>;
+    last_checkpoint_lsn: t.Union<t.Codec<null, null, string, t.CodecProps>, t.IdentityCodec<t.CodecType.String>>;
+}>;
+export type ActiveCheckpoint = t.Encoded<typeof ActiveCheckpoint>;
+export type ActiveCheckpointDecoded = t.Decoded<typeof ActiveCheckpoint>;

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

@@ -0,0 +1,19 @@
+import * as t from 'ts-codec';
+export declare const ActiveCheckpointPayload: t.ObjectCodec<{
+    active_checkpoint: t.ObjectCodec<{
+        id: t.Codec<number, number, "pg_number", t.CodecProps>;
+        last_checkpoint: t.Union<t.Codec<null, null, string, t.CodecProps>, t.Codec<bigint, string | number, string, t.CodecProps>>;
+        last_checkpoint_lsn: t.Union<t.Codec<null, null, string, t.CodecProps>, t.IdentityCodec<t.CodecType.String>>;
+    }>;
+}>;
+export type ActiveCheckpointPayload = t.Encoded<typeof ActiveCheckpointPayload>;
+export type ActiveCheckpointPayloadDecoded = t.Decoded<typeof ActiveCheckpointPayload>;
+export declare const ActiveCheckpointNotification: t.Codec<{
+    active_checkpoint: {
+        id: number;
+        last_checkpoint: bigint | null;
+        last_checkpoint_lsn: string | null;
+    };
+}, string, string, t.CodecProps>;
+export type ActiveCheckpointNotification = t.Encoded<typeof ActiveCheckpointNotification>;
+export type ActiveCheckpointNotificationDecoded = t.Decoded<typeof ActiveCheckpointNotification>;

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

@@ -0,0 +1,22 @@
+import * as t from 'ts-codec';
+export declare enum OpType {
+    PUT = "PUT",
+    REMOVE = "REMOVE",
+    MOVE = "MOVE",
+    CLEAR = "CLEAR"
+}
+export declare const BucketData: t.ObjectCodec<{
+    group_id: t.Codec<number, number, "pg_number", t.CodecProps>;
+    bucket_name: t.IdentityCodec<t.CodecType.String>;
+    op_id: t.Codec<bigint, string | number, string, t.CodecProps>;
+    op: t.EnumCodec<typeof OpType>;
+    source_table: t.Union<t.Codec<null, null, string, t.CodecProps>, t.IdentityCodec<t.CodecType.String>>;
+    source_key: t.Union<t.Codec<null, null, string, t.CodecProps>, t.Codec<Buffer, string, "hexBuffer", t.CodecProps>>;
+    table_name: t.Union<t.Codec<string, string, string, t.CodecProps>, t.Codec<null, null, t.CodecType.Null, t.CodecProps>>;
+    row_id: t.Union<t.Codec<string, string, string, t.CodecProps>, t.Codec<null, null, t.CodecType.Null, t.CodecProps>>;
+    checksum: t.Codec<bigint, string | number, string, t.CodecProps>;
+    data: t.Union<t.Codec<null, null, string, t.CodecProps>, t.IdentityCodec<t.CodecType.String>>;
+    target_op: t.Union<t.Codec<null, null, string, t.CodecProps>, t.Codec<bigint, string | number, string, t.CodecProps>>;
+}>;
+export type BucketData = t.Encoded<typeof BucketData>;
+export type BucketDataDecoded = t.Decoded<typeof BucketData>;

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

@@ -0,0 +1,11 @@
+import * as t from 'ts-codec';
+export declare const BucketParameters: t.ObjectCodec<{
+    id: t.Codec<bigint, string | number, string, t.CodecProps>;
+    group_id: t.Codec<number, number, "pg_number", t.CodecProps>;
+    source_table: t.IdentityCodec<t.CodecType.String>;
+    source_key: t.Codec<Buffer, string, "hexBuffer", t.CodecProps>;
+    lookup: t.Codec<Buffer, string, "hexBuffer", t.CodecProps>;
+    bucket_parameters: t.IdentityCodec<t.CodecType.String>;
+}>;
+export type BucketParameters = t.Encoded<typeof BucketParameters>;
+export type BucketParametersDecoded = t.Decoded<typeof BucketParameters>;

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

@@ -0,0 +1,22 @@
+import * as t from 'ts-codec';
+export declare const CurrentBucket: t.ObjectCodec<{
+    bucket: t.IdentityCodec<t.CodecType.String>;
+    table: t.IdentityCodec<t.CodecType.String>;
+    id: t.IdentityCodec<t.CodecType.String>;
+}>;
+export type CurrentBucket = t.Encoded<typeof CurrentBucket>;
+export type CurrentBucketDecoded = t.Decoded<typeof CurrentBucket>;
+export declare const CurrentData: t.ObjectCodec<{
+    buckets: t.Codec<{
+        id: string;
+        bucket: string;
+        table: string;
+    }[], string, string, t.CodecProps>;
+    data: t.Codec<Buffer, string, "hexBuffer", t.CodecProps>;
+    group_id: t.Codec<number, number, "pg_number", t.CodecProps>;
+    lookups: t.ArrayCodec<t.Codec<Buffer, string, "hexBuffer", t.CodecProps>>;
+    source_key: t.Codec<Buffer, 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>;

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

@@ -0,0 +1,6 @@
+import * as t from 'ts-codec';
+export declare const Instance: t.ObjectCodec<{
+    id: t.IdentityCodec<t.CodecType.String>;
+}>;
+export type Instance = t.Encoded<typeof Instance>;
+export type InstanceDecoded = t.Decoded<typeof Instance>;

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

@@ -0,0 +1,12 @@
+import { framework } from '@powersync/service-core';
+import * as t from 'ts-codec';
+export declare const Migration: t.ObjectCodec<{
+    last_run: t.IdentityCodec<t.CodecType.String>;
+    log: t.Codec<{
+        name: string;
+        direction: framework.Direction;
+        timestamp: Date;
+    }[], string, string, t.CodecProps>;
+}>;
+export type Migration = t.Encoded<typeof Migration>;
+export type MigrationDecoded = t.Decoded<typeof Migration>;

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

@@ -0,0 +1,31 @@
+import * as t from 'ts-codec';
+export type StoredRelationId = {
+    object_id: string | number;
+};
+export declare const ColumnDescriptor: t.ObjectCodec<{
+    name: t.IdentityCodec<t.CodecType.String>;
+    /**
+     *  The type of the column ie VARCHAR, INT, etc
+     */
+    type: t.OptionalCodec<t.Codec<string, string, string, t.CodecProps>>;
+    /**
+     *  Some data sources have a type id that can be used to identify the type of the column
+     */
+    typeId: t.OptionalCodec<t.Codec<number, number, string, t.CodecProps>>;
+}>;
+export declare const SourceTable: t.ObjectCodec<{
+    id: t.IdentityCodec<t.CodecType.String>;
+    group_id: t.Codec<number, number, "pg_number", t.CodecProps>;
+    connection_id: t.Codec<bigint, string | number, string, t.CodecProps>;
+    relation_id: t.Union<t.Codec<null, null, string, t.CodecProps>, t.Codec<StoredRelationId, string, string, t.CodecProps>>;
+    schema_name: t.IdentityCodec<t.CodecType.String>;
+    table_name: t.IdentityCodec<t.CodecType.String>;
+    replica_id_columns: t.Union<t.Codec<null, null, string, t.CodecProps>, t.Codec<{
+        name: string;
+        type?: string | undefined;
+        typeId?: number | undefined;
+    }[], string, string, t.CodecProps>>;
+    snapshot_done: t.IdentityCodec<t.CodecType.Boolean>;
+}>;
+export type SourceTable = t.Encoded<typeof SourceTable>;
+export type SourceTableDecoded = t.Decoded<typeof SourceTable>;