@powersync/service-module-postgres-storage 0.0.0-dev-20250122110924 → 0.0.0-dev-20250227082606

package/src/storage/PostgresSyncRulesStorage.ts

@@ -1,6 +1,15 @@
 import * as lib_postgres from '@powersync/lib-service-postgres';
-import { DisposableObserver, ReplicationAssertionError } from '@powersync/lib-services-framework';
-import { storage, utils } from '@powersync/service-core';
+import { ReplicationAssertionError } from '@powersync/lib-services-framework';
+import {
+  BroadcastIterable,
+  CHECKPOINT_INVALIDATE_ALL,
+  CheckpointChanges,
+  GetCheckpointChangesOptions,
+  LastValueSink,
+  storage,
+  utils,
+  WatchWriteCheckpointOptions
+} from '@powersync/service-core';
 import { JSONBig } from '@powersync/service-jsonbig';
 import * as sync_rules from '@powersync/service-sync-rules';
 import * as uuid from 'uuid';
@@ -8,14 +17,18 @@ import { BIGINT_MAX } from '../types/codecs.js';
 import { models, RequiredOperationBatchLimits } from '../types/types.js';
 import { replicaIdToSubkey } from '../utils/bson.js';
 import { mapOpEntry } from '../utils/bucket-data.js';
+import * as timers from 'timers/promises';
 
+import * as framework from '@powersync/lib-services-framework';
 import { StatementParam } from '@powersync/service-jpgwire';
-import { StoredRelationId } from '../types/models/SourceTable.js';
+import { SourceTableDecoded, StoredRelationId } from '../types/models/SourceTable.js';
 import { pick } from '../utils/ts-codec.js';
 import { PostgresBucketBatch } from './batch/PostgresBucketBatch.js';
 import { PostgresWriteCheckpointAPI } from './checkpoints/PostgresWriteCheckpointAPI.js';
 import { PostgresBucketStorageFactory } from './PostgresBucketStorageFactory.js';
 import { PostgresCompactor } from './PostgresCompactor.js';
+import { wrapWithAbort } from 'ix/asynciterable/operators/withabort.js';
+import { Decoded } from 'ts-codec';
 
 export type PostgresSyncRulesStorageOptions = {
   factory: PostgresBucketStorageFactory;
@@ -26,7 +39,7 @@ export type PostgresSyncRulesStorageOptions = {
 };
 
 export class PostgresSyncRulesStorage
-  extends DisposableObserver<storage.SyncRulesBucketStorageListener>
+  extends framework.BaseObserver<storage.SyncRulesBucketStorageListener>
   implements storage.SyncRulesBucketStorage
 {
   public readonly group_id: number;
@@ -34,6 +47,8 @@ export class PostgresSyncRulesStorage
   public readonly slot_name: string;
   public readonly factory: PostgresBucketStorageFactory;
 
+  private sharedIterator = new BroadcastIterable((signal) => this.watchActiveCheckpoint(signal));
+
   protected db: lib_postgres.DatabaseClient;
   protected writeCheckpointAPI: PostgresWriteCheckpointAPI;
 
@@ -151,21 +166,39 @@ export class PostgresSyncRulesStorage
       type_oid: typeof column.typeId !== 'undefined' ? Number(column.typeId) : column.typeId
     }));
     return this.db.transaction(async (db) => {
-      let sourceTableRow = await db.sql`
-        SELECT
-          *
-        FROM
-          source_tables
-        WHERE
-          group_id = ${{ type: 'int4', value: group_id }}
-          AND connection_id = ${{ type: 'int4', value: connection_id }}
-          AND relation_id = ${{ type: 'jsonb', value: { object_id: objectId } satisfies StoredRelationId }}
-          AND schema_name = ${{ type: 'varchar', value: schema }}
-          AND table_name = ${{ type: 'varchar', value: table }}
-          AND replica_id_columns = ${{ type: 'jsonb', value: columns }}
-      `
-        .decoded(models.SourceTable)
-        .first();
+      let sourceTableRow: SourceTableDecoded | null;
+      if (objectId != null) {
+        sourceTableRow = await db.sql`
+          SELECT
+            *
+          FROM
+            source_tables
+          WHERE
+            group_id = ${{ type: 'int4', value: group_id }}
+            AND connection_id = ${{ type: 'int4', value: connection_id }}
+            AND relation_id = ${{ type: 'jsonb', value: { object_id: objectId } satisfies StoredRelationId }}
+            AND schema_name = ${{ type: 'varchar', value: schema }}
+            AND table_name = ${{ type: 'varchar', value: table }}
+            AND replica_id_columns = ${{ type: 'jsonb', value: columns }}
+        `
+          .decoded(models.SourceTable)
+          .first();
+      } else {
+        sourceTableRow = await db.sql`
+          SELECT
+            *
+          FROM
+            source_tables
+          WHERE
+            group_id = ${{ type: 'int4', value: group_id }}
+            AND connection_id = ${{ type: 'int4', value: connection_id }}
+            AND schema_name = ${{ type: 'varchar', value: schema }}
+            AND table_name = ${{ type: 'varchar', value: table }}
+            AND replica_id_columns = ${{ type: 'jsonb', value: columns }}
+        `
+          .decoded(models.SourceTable)
+          .first();
+      }
 
       if (sourceTableRow == null) {
         const row = await db.sql`
@@ -184,7 +217,7 @@ export class PostgresSyncRulesStorage
               ${{ type: 'varchar', value: uuid.v4() }},
               ${{ type: 'int4', value: group_id }},
               ${{ type: 'int4', value: connection_id }},
-              --- The objectId can be string | number, we store it as jsonb value
+              --- The objectId can be string | number | undefined, we store it as jsonb value
               ${{ type: 'jsonb', value: { object_id: objectId } satisfies StoredRelationId }},
               ${{ type: 'varchar', value: schema }},
               ${{ type: 'varchar', value: table }},
@@ -211,25 +244,47 @@ export class PostgresSyncRulesStorage
       sourceTable.syncData = options.sync_rules.tableSyncsData(sourceTable);
       sourceTable.syncParameters = options.sync_rules.tableSyncsParameters(sourceTable);
 
-      const truncatedTables = await db.sql`
-        SELECT
-          *
-        FROM
-          source_tables
-        WHERE
-          group_id = ${{ type: 'int4', value: group_id }}
-          AND connection_id = ${{ type: 'int4', value: connection_id }}
-          AND id != ${{ type: 'varchar', value: sourceTableRow!.id }}
-          AND (
-            relation_id = ${{ type: 'jsonb', value: { object_id: objectId } satisfies StoredRelationId }}
-            OR (
+      let truncatedTables: SourceTableDecoded[] = [];
+      if (objectId != null) {
+        // relation_id present - check for renamed tables
+        truncatedTables = await db.sql`
+          SELECT
+            *
+          FROM
+            source_tables
+          WHERE
+            group_id = ${{ type: 'int4', value: group_id }}
+            AND connection_id = ${{ type: 'int4', value: connection_id }}
+            AND id != ${{ type: 'varchar', value: sourceTableRow!.id }}
+            AND (
+              relation_id = ${{ type: 'jsonb', value: { object_id: objectId } satisfies StoredRelationId }}
+              OR (
+                schema_name = ${{ type: 'varchar', value: schema }}
+                AND table_name = ${{ type: 'varchar', value: table }}
+              )
+            )
+        `
+          .decoded(models.SourceTable)
+          .rows();
+      } else {
+        // relation_id not present - only check for changed replica_id_columns
+        truncatedTables = await db.sql`
+          SELECT
+            *
+          FROM
+            source_tables
+          WHERE
+            group_id = ${{ type: 'int4', value: group_id }}
+            AND connection_id = ${{ type: 'int4', value: connection_id }}
+            AND id != ${{ type: 'varchar', value: sourceTableRow!.id }}
+            AND (
               schema_name = ${{ type: 'varchar', value: schema }}
               AND table_name = ${{ type: 'varchar', value: table }}
             )
-          )
-      `
-        .decoded(models.SourceTable)
-        .rows();
+        `
+          .decoded(models.SourceTable)
+          .rows();
+      }
 
       return {
         table: sourceTable,
@@ -272,7 +327,7 @@ export class PostgresSyncRulesStorage
 
     const checkpoint_lsn = syncRules?.last_checkpoint_lsn ?? null;
 
-    await using batch = new PostgresBucketBatch({
+    const batch = new PostgresBucketBatch({
       db: this.db,
       sync_rules: this.sync_rules.parsed(options).sync_rules,
       group_id: this.group_id,
@@ -602,7 +657,10 @@ export class PostgresSyncRulesStorage
         SET
           state = ${{ type: 'varchar', value: storage.SyncRuleState.STOP }}
         WHERE
-          state = ${{ type: 'varchar', value: storage.SyncRuleState.ACTIVE }}
+          (
+            state = ${{ value: storage.SyncRuleState.ACTIVE, type: 'varchar' }}
+            OR state = ${{ value: storage.SyncRuleState.ERRORED, type: 'varchar' }}
+          )
           AND id != ${{ type: 'int4', value: this.group_id }}
       `.execute();
     });
@@ -663,4 +721,139 @@ export class PostgresSyncRulesStorage
       })
     );
   }
+
+  async getActiveCheckpoint(): Promise<storage.ReplicationCheckpoint> {
+    const activeCheckpoint = await this.db.sql`
+      SELECT
+        id,
+        last_checkpoint,
+        last_checkpoint_lsn
+      FROM
+        sync_rules
+      WHERE
+        state = ${{ value: storage.SyncRuleState.ACTIVE, type: 'varchar' }}
+        OR state = ${{ value: storage.SyncRuleState.ERRORED, type: 'varchar' }}
+      ORDER BY
+        id DESC
+      LIMIT
+        1
+    `
+      .decoded(models.ActiveCheckpoint)
+      .first();
+
+    return this.makeActiveCheckpoint(activeCheckpoint);
+  }
+
+  async *watchWriteCheckpoint(options: WatchWriteCheckpointOptions): AsyncIterable<storage.StorageCheckpointUpdate> {
+    let lastCheckpoint: utils.OpId | null = null;
+    let lastWriteCheckpoint: bigint | null = null;
+
+    const { signal, user_id } = options;
+
+    const iter = wrapWithAbort(this.sharedIterator, signal);
+    for await (const cp of iter) {
+      const { checkpoint, lsn } = cp;
+
+      // lsn changes are not important by itself.
+      // What is important is:
+      // 1. checkpoint (op_id) changes.
+      // 2. write checkpoint changes for the specific user
+      const lsnFilters: Record<string, string> = lsn ? { 1: lsn } : {};
+
+      const currentWriteCheckpoint = await this.lastWriteCheckpoint({
+        user_id,
+        heads: {
+          ...lsnFilters
+        }
+      });
+
+      if (currentWriteCheckpoint == lastWriteCheckpoint && checkpoint == lastCheckpoint) {
+        // No change - wait for next one
+        // In some cases, many LSNs may be produced in a short time.
+        // Add a delay to throttle the write checkpoint lookup a bit.
+        await timers.setTimeout(20 + 10 * Math.random());
+        continue;
+      }
+
+      lastWriteCheckpoint = currentWriteCheckpoint;
+      lastCheckpoint = checkpoint;
+
+      yield {
+        base: cp,
+        writeCheckpoint: currentWriteCheckpoint,
+        update: CHECKPOINT_INVALIDATE_ALL
+      };
+    }
+  }
+
+  protected async *watchActiveCheckpoint(signal: AbortSignal): AsyncIterable<storage.ReplicationCheckpoint> {
+    const doc = await this.db.sql`
+      SELECT
+        id,
+        last_checkpoint,
+        last_checkpoint_lsn
+      FROM
+        sync_rules
+      WHERE
+        state = ${{ value: storage.SyncRuleState.ACTIVE, type: 'varchar' }}
+        OR state = ${{ value: storage.SyncRuleState.ERRORED, type: 'varchar' }}
+      LIMIT
+        1
+    `
+      .decoded(models.ActiveCheckpoint)
+      .first();
+
+    if (doc == null) {
+      // Abort the connections - clients will have to retry later.
+      throw new framework.ServiceError(framework.ErrorCode.PSYNC_S2302, 'No active sync rules available');
+    }
+
+    const sink = new LastValueSink<string>(undefined);
+
+    const disposeListener = this.db.registerListener({
+      notification: (notification) => sink.next(notification.payload)
+    });
+
+    signal.addEventListener('aborted', async () => {
+      disposeListener();
+      sink.complete();
+    });
+
+    yield this.makeActiveCheckpoint(doc);
+
+    let lastOp: storage.ReplicationCheckpoint | null = null;
+    for await (const payload of sink.withSignal(signal)) {
+      if (signal.aborted) {
+        return;
+      }
+
+      const notification = models.ActiveCheckpointNotification.decode(payload);
+      if (notification.active_checkpoint == null) {
+        continue;
+      }
+      if (Number(notification.active_checkpoint.id) != doc.id) {
+        // Active sync rules changed - abort and restart the stream
+        break;
+      }
+
+      const activeCheckpoint = this.makeActiveCheckpoint(notification.active_checkpoint);
+
+      if (lastOp == null || activeCheckpoint.lsn != lastOp.lsn || activeCheckpoint.checkpoint != lastOp.checkpoint) {
+        lastOp = activeCheckpoint;
+        yield activeCheckpoint;
+      }
+    }
+  }
+
+  async getCheckpointChanges(options: GetCheckpointChangesOptions): Promise<CheckpointChanges> {
+    // We do not track individual changes yet
+    return CHECKPOINT_INVALIDATE_ALL;
+  }
+
+  private makeActiveCheckpoint(row: models.ActiveCheckpointDecoded | null) {
+    return {
+      checkpoint: utils.timestampToOpId(row?.last_checkpoint ?? 0n),
+      lsn: row?.last_checkpoint_lsn ?? null
+    } satisfies storage.ReplicationCheckpoint;
+  }
 }

package/src/storage/batch/PostgresBucketBatch.ts

@@ -1,7 +1,7 @@
 import * as lib_postgres from '@powersync/lib-service-postgres';
 import {
+  BaseObserver,
   container,
-  DisposableObserver,
   ErrorCode,
   errors,
   logger,
@@ -51,7 +51,7 @@ type StatefulCheckpointDecoded = t.Decoded<typeof StatefulCheckpoint>;
 const MAX_ROW_SIZE = 15 * 1024 * 1024;
 
 export class PostgresBucketBatch
-  extends DisposableObserver<storage.BucketBatchStorageListener>
+  extends BaseObserver<storage.BucketBatchStorageListener>
   implements storage.BucketStorageBatch
 {
   public last_flushed_op: bigint | null = null;
@@ -87,9 +87,13 @@ export class PostgresBucketBatch
     return this.last_checkpoint_lsn;
   }
 
+  async [Symbol.asyncDispose]() {
+    super.clearListeners();
+  }
+
   async save(record: storage.SaveOptions): Promise<storage.FlushedResult | null> {
     // TODO maybe share with abstract class
-    const { after, afterReplicaId, before, beforeReplicaId, sourceTable, tag } = record;
+    const { after, before, sourceTable, tag } = record;
     for (const event of this.getTableEvents(sourceTable)) {
       this.iterateListeners((cb) =>
         cb.replicationEvent?.({
@@ -245,7 +249,10 @@ export class PostgresBucketBatch
 
   private async flushInner(): Promise<storage.FlushedResult | null> {
     const batch = this.batch;
-    if (batch == null) {
+    // Don't flush empty batches
+    // This helps prevent feedback loops when using the same database for
+    // the source data and sync bucket storage
+    if (batch == null || batch.length == 0) {
       return null;
     }
 
@@ -275,7 +282,9 @@ export class PostgresBucketBatch
     return { flushed_op: String(lastOp) };
   }
 
-  async commit(lsn: string): Promise<boolean> {
+  async commit(lsn: string, options?: storage.BucketBatchCommitOptions): Promise<boolean> {
+    const { createEmptyCheckpoints } = { ...storage.DEFAULT_BUCKET_BATCH_COMMIT_OPTIONS, ...options };
+
     await this.flush();
 
     if (this.last_checkpoint_lsn != null && lsn < this.last_checkpoint_lsn) {
@@ -309,6 +318,12 @@ export class PostgresBucketBatch
 
       return false;
     }
+
+    // Don't create a checkpoint if there were no changes
+    if (!createEmptyCheckpoints && this.persisted_op == null) {
+      return false;
+    }
+
     const now = new Date().toISOString();
     const update: Partial<models.SyncRules> = {
       last_checkpoint_lsn: lsn,
@@ -488,7 +503,7 @@ export class PostgresBucketBatch
               jsonb_array_elements(${{ type: 'jsonb', value: sizeLookups }}::jsonb) AS FILTER
           )
         SELECT
-          pg_column_size(c.data) AS data_size,
+          octet_length(c.data) AS data_size,
           c.source_table,
           c.source_key
         FROM
@@ -529,23 +544,20 @@ export class PostgresBucketBatch
       const current_data_lookup = new Map<string, CurrentDataDecoded>();
       for await (const currentDataRows of db.streamRows<CurrentData>({
         statement: /* sql */ `
-          WITH
-            filter_data AS (
-              SELECT
-                decode(FILTER ->> 'source_key', 'hex') AS source_key, -- Decoding from hex to bytea
-                (FILTER ->> 'source_table') AS source_table_id
-              FROM
-                jsonb_array_elements($1::jsonb) AS FILTER
-            )
           SELECT
-            --- With skipExistingRows, we only need to know whether or not the row exists.
             ${this.options.skip_existing_rows ? `c.source_table, c.source_key` : 'c.*'}
           FROM
             current_data c
-            JOIN filter_data f ON c.source_table = f.source_table_id
+            JOIN (
+              SELECT
+                decode(FILTER ->> 'source_key', 'hex') AS source_key,
+                FILTER ->> 'source_table' AS source_table_id
+              FROM
+                jsonb_array_elements($1::jsonb) AS FILTER
+            ) f ON c.source_table = f.source_table_id
             AND c.source_key = f.source_key
           WHERE
-            c.group_id = $2
+            c.group_id = $2;
         `,
         params: [
           {
@@ -553,7 +565,7 @@ export class PostgresBucketBatch
             value: lookups
           },
           {
-            type: 'int8',
+            type: 'int4',
             value: this.group_id
           }
         ]
@@ -610,7 +622,12 @@ export class PostgresBucketBatch
         await persistedBatch.flush(db);
       }
     }
-    return resumeBatch;
+
+    // Don't return empty batches
+    if (resumeBatch?.batch.length) {
+      return resumeBatch;
+    }
+    return null;
   }
 
   protected async saveOperation(
@@ -627,8 +644,8 @@ export class PostgresBucketBatch
 
     let existingBuckets: CurrentBucket[] = [];
     let newBuckets: CurrentBucket[] = [];
-    let existingLookups: Buffer[] = [];
-    let newLookups: Buffer[] = [];
+    let existingLookups: Buffer<ArrayBuffer>[] = [];
+    let newLookups: Buffer<ArrayBuffer>[] = [];
 
     if (this.options.skip_existing_rows) {
       if (record.tag == storage.SaveOperationTag.INSERT) {
@@ -682,7 +699,7 @@ export class PostgresBucketBatch
       }
     }
 
-    let afterData: Buffer | undefined;
+    let afterData: Buffer<ArrayBuffer> | undefined;
     if (afterId != null && !this.options.store_current_data) {
       afterData = storage.serializeBson({});
     } else if (afterId != null) {

package/src/storage/batch/PostgresPersistedBatch.ts

@@ -256,33 +256,6 @@ export class PostgresPersistedBatch {
   protected async flushBucketData(db: lib_postgres.WrappedConnection) {
     if (this.bucketDataInserts.length > 0) {
       await db.sql`
-        WITH
-          parsed_data AS (
-            SELECT
-              group_id,
-              bucket_name,
-              source_table,
-              decode(source_key, 'hex') AS source_key, -- Decode hex to bytea
-              table_name,
-              op,
-              row_id,
-              checksum,
-              data,
-              target_op
-            FROM
-              jsonb_to_recordset(${{ type: 'jsonb', value: this.bucketDataInserts }}::jsonb) AS t (
-                group_id integer,
-                bucket_name text,
-                source_table text,
-                source_key text, -- Input as hex string
-                table_name text,
-                op text,
-                row_id text,
-                checksum bigint,
-                data text,
-                target_op bigint
-              )
-          )
         INSERT INTO
           bucket_data (
             group_id,
@@ -303,14 +276,25 @@ export class PostgresPersistedBatch {
           nextval('op_id_sequence'),
           op,
           source_table,
-          source_key, -- Already decoded
+          decode(source_key, 'hex') AS source_key,
           table_name,
           row_id,
           checksum,
           data,
           target_op
         FROM
-          parsed_data;
+          json_to_recordset(${{ type: 'json', value: this.bucketDataInserts }}::json) AS t (
+            group_id integer,
+            bucket_name text,
+            source_table text,
+            source_key text, -- Input as hex string
+            table_name text,
+            op text,
+            row_id text,
+            checksum bigint,
+            data text,
+            target_op bigint
+          );
       `.execute();
     }
   }
@@ -318,23 +302,6 @@ export class PostgresPersistedBatch {
   protected async flushParameterData(db: lib_postgres.WrappedConnection) {
     if (this.parameterDataInserts.length > 0) {
       await db.sql`
-        WITH
-          parsed_data AS (
-            SELECT
-              group_id,
-              source_table,
-              decode(source_key, 'hex') AS source_key, -- Decode hex to bytea
-              decode(lookup, 'hex') AS lookup, -- Decode hex to bytea
-              bucket_parameters
-            FROM
-              jsonb_to_recordset(${{ type: 'jsonb', value: this.parameterDataInserts }}::jsonb) AS t (
-                group_id integer,
-                source_table text,
-                source_key text, -- Input as hex string
-                lookup text, -- Input as hex string
-                bucket_parameters text -- Input as stringified JSON
-              )
-          )
         INSERT INTO
           bucket_parameters (
             group_id,
@@ -346,11 +313,17 @@ export class PostgresPersistedBatch {
         SELECT
           group_id,
           source_table,
-          source_key, -- Already decoded
-          lookup, -- Already decoded
+          decode(source_key, 'hex') AS source_key, -- Decode hex to bytea
+          decode(lookup, 'hex') AS lookup, -- Decode hex to bytea
           bucket_parameters
         FROM
-          parsed_data;
+          json_to_recordset(${{ type: 'json', value: this.parameterDataInserts }}::json) AS t (
+            group_id integer,
+            source_table text,
+            source_key text, -- Input as hex string
+            lookup text, -- Input as hex string
+            bucket_parameters text -- Input as stringified JSON
+          )
       `.execute();
     }
   }
@@ -358,33 +331,6 @@ export class PostgresPersistedBatch {
   protected async flushCurrentData(db: lib_postgres.WrappedConnection) {
     if (this.currentDataInserts.size > 0) {
       await db.sql`
-        WITH
-          parsed_data AS (
-            SELECT
-              group_id,
-              source_table,
-              decode(source_key, 'hex') AS source_key, -- Decode hex to bytea
-              buckets::jsonb AS buckets,
-              decode(data, 'hex') AS data, -- Decode hex to bytea
-              ARRAY(
-                SELECT
-                  decode((value ->> 0)::TEXT, 'hex')
-                FROM
-                  jsonb_array_elements(lookups::jsonb) AS value
-              ) AS lookups -- Decode array of hex strings to bytea[]
-            FROM
-              jsonb_to_recordset(${{
-          type: 'jsonb',
-          value: Array.from(this.currentDataInserts.values())
-        }}::jsonb) AS t (
-                group_id integer,
-                source_table text,
-                source_key text, -- Input as hex string
-                buckets text,
-                data text, -- Input as hex string
-                lookups text -- Input as stringified JSONB array of hex strings
-              )
-          )
         INSERT INTO
           current_data (
             group_id,
@@ -397,12 +343,24 @@ export class PostgresPersistedBatch {
         SELECT
           group_id,
           source_table,
-          source_key, -- Already decoded
-          buckets,
-          data, -- Already decoded
-          lookups -- Already decoded
+          decode(source_key, 'hex') AS source_key, -- Decode hex to bytea
+          buckets::jsonb AS buckets,
+          decode(data, 'hex') AS data, -- Decode hex to bytea
+          array(
+            SELECT
+              decode(element, 'hex')
+            FROM
+              unnest(lookups) AS element
+          ) AS lookups
         FROM
-          parsed_data
+          json_to_recordset(${{ type: 'json', value: Array.from(this.currentDataInserts.values()) }}::json) AS t (
+            group_id integer,
+            source_table text,
+            source_key text, -- Input as hex string
+            buckets text,
+            data text, -- Input as hex string
+            lookups TEXT[] -- Input as stringified JSONB array of hex strings
+          )
         ON CONFLICT (group_id, source_table, source_key) DO UPDATE
         SET
           buckets = EXCLUDED.buckets,

package/src/types/models/SourceTable.ts

@@ -2,7 +2,7 @@ import * as t from 'ts-codec';
 import { bigint, jsonb, jsonb_raw, pgwire_number } from '../codecs.js';
 
 export type StoredRelationId = {
-  object_id: string | number;
+  object_id: string | number | undefined;
 };
 
 export const ColumnDescriptor = t.object({

package/src/types/types.ts

@@ -53,6 +53,7 @@ export type RequiredOperationBatchLimits = Required<OperationBatchLimits>;
 
 export type NormalizedPostgresStorageConfig = pg_wire.NormalizedConnectionConfig & {
   batch_limits: RequiredOperationBatchLimits;
+  max_pool_size: number;
 };
 
 export const normalizePostgresStorageConfig = (