@powersync/service-module-postgres 0.16.10 → 0.16.12

package/src/replication/ConnectionManagerFactory.ts

@@ -1,30 +1,31 @@
-import { PgManager } from './PgManager.js';
-import { NormalizedPostgresConnectionConfig } from '../types/types.js';
-import { PgPoolOptions } from '@powersync/service-jpgwire';
 import { logger } from '@powersync/lib-services-framework';
-import { CustomTypeRegistry } from '../types/registry.js';
+import { PgPoolOptions } from '@powersync/service-jpgwire';
+import { NormalizedPostgresConnectionConfig } from '../types/types.js';
+import { PgManager } from './PgManager.js';
 
 export class ConnectionManagerFactory {
-  private readonly connectionManagers: PgManager[];
+  private readonly connectionManagers = new Set<PgManager>();
   public readonly dbConnectionConfig: NormalizedPostgresConnectionConfig;
 
-  constructor(
-    dbConnectionConfig: NormalizedPostgresConnectionConfig,
-    private readonly registry: CustomTypeRegistry
-  ) {
+  constructor(dbConnectionConfig: NormalizedPostgresConnectionConfig) {
     this.dbConnectionConfig = dbConnectionConfig;
-    this.connectionManagers = [];
   }
 
   create(poolOptions: PgPoolOptions) {
-    const manager = new PgManager(this.dbConnectionConfig, { ...poolOptions, registry: this.registry });
-    this.connectionManagers.push(manager);
+    const manager = new PgManager(this.dbConnectionConfig, { ...poolOptions });
+    this.connectionManagers.add(manager);
+
+    manager.registerListener({
+      onEnded: () => {
+        this.connectionManagers.delete(manager);
+      }
+    });
     return manager;
   }
 
   async shutdown() {
     logger.info('Shutting down Postgres connection Managers...');
-    for (const manager of this.connectionManagers) {
+    for (const manager of [...this.connectionManagers]) {
       await manager.end();
     }
     logger.info('Postgres connection Managers shutdown completed.');

package/src/replication/PgManager.ts

@@ -1,21 +1,23 @@
+import { BaseObserver } from '@powersync/lib-services-framework';
 import * as pgwire from '@powersync/service-jpgwire';
 import semver from 'semver';
+import { PostgresTypeResolver } from '../types/resolver.js';
 import { NormalizedPostgresConnectionConfig } from '../types/types.js';
 import { getApplicationName } from '../utils/application-name.js';
-import { PostgresTypeResolver } from '../types/resolver.js';
 import { getServerVersion } from '../utils/postgres_version.js';
-import { CustomTypeRegistry } from '../types/registry.js';
 
-export interface PgManagerOptions extends pgwire.PgPoolOptions {
-  registry: CustomTypeRegistry;
-}
+export interface PgManagerOptions extends pgwire.PgPoolOptions {}
 
 /**
  * Shorter timeout for snapshot connections than for replication connections.
  */
 const SNAPSHOT_SOCKET_TIMEOUT = 30_000;
 
-export class PgManager {
+export interface PgManagerListener {
+  onEnded(): void;
+}
+
+export class PgManager extends BaseObserver<PgManagerListener> {
   /**
    * Do not use this for any transactions.
    */
@@ -29,9 +31,10 @@ export class PgManager {
     public options: NormalizedPostgresConnectionConfig,
     public poolOptions: PgManagerOptions
   ) {
+    super();
     // The pool is lazy - no connections are opened until a query is performed.
     this.pool = pgwire.connectPgWirePool(this.options, poolOptions);
-    this.types = new PostgresTypeResolver(poolOptions.registry, this.pool);
+    this.types = new PostgresTypeResolver(this.pool);
   }
 
   public get connectionTag() {
@@ -83,8 +86,9 @@ export class PgManager {
     for (let result of await Promise.allSettled([
       this.pool.end(),
       ...this.connectionPromises.map(async (promise) => {
-        const connection = await promise;
-        return await connection.end();
+        // Wait for connection attempts to finish, but do not throw connection errors here
+        const connection = await promise.catch((_) => {});
+        return await connection?.end();
       })
     ])) {
       // Throw the first error, if any
@@ -92,14 +96,18 @@ export class PgManager {
         throw result.reason;
       }
     }
+    this.iterateListeners((listener) => {
+      listener.onEnded?.();
+    });
   }
 
   async destroy() {
     this.pool.destroy();
     for (let result of await Promise.allSettled([
       ...this.connectionPromises.map(async (promise) => {
-        const connection = await promise;
-        return connection.destroy();
+        // Wait for connection attempts to finish, but do not throw connection errors here
+        const connection = await promise.catch((_) => {});
+        return connection?.destroy();
       })
     ])) {
       // Throw the first error, if any
@@ -107,5 +115,8 @@ export class PgManager {
         throw result.reason;
       }
     }
+    this.iterateListeners((listener) => {
+      listener.onEnded?.();
+    });
   }
 }

package/src/replication/PostgresErrorRateLimiter.ts

@@ -1,5 +1,6 @@
 import { setTimeout } from 'timers/promises';
 import { ErrorRateLimiter } from '@powersync/service-core';
+import { MissingReplicationSlotError } from './WalStream.js';
 
 export class PostgresErrorRateLimiter implements ErrorRateLimiter {
   nextAllowed: number = Date.now();
@@ -17,7 +18,10 @@ export class PostgresErrorRateLimiter implements ErrorRateLimiter {
 
   reportError(e: any): void {
     const message = (e.message as string) ?? '';
-    if (message.includes('password authentication failed')) {
+    if (e instanceof MissingReplicationSlotError) {
+      // Short delay for a retrying (re-creating the slot)
+      this.setDelay(2_000);
+    } else if (message.includes('password authentication failed')) {
       // Wait 15 minutes, to avoid triggering Supabase's fail2ban
       this.setDelay(900_000);
     } else if (message.includes('ENOTFOUND')) {

package/src/replication/WalStream.ts

@@ -4,7 +4,6 @@ import {
   DatabaseConnectionError,
   logger as defaultLogger,
   ErrorCode,
-  errors,
   Logger,
   ReplicationAbortedError,
   ReplicationAssertionError
@@ -100,8 +99,10 @@ export const sendKeepAlive = async (db: pgwire.PgClient) => {
 };
 
 export class MissingReplicationSlotError extends Error {
-  constructor(message: string) {
+  constructor(message: string, cause?: any) {
     super(message);
+
+    this.cause = cause;
   }
 }
 
@@ -304,135 +305,54 @@ export class WalStream {
       })
     )[0];
 
+    // Previously we also used pg_catalog.pg_logical_slot_peek_binary_changes to confirm that we can query the slot.
+    // However, there were some edge cases where the query times out, repeating the query, ultimately
+    // causing high load on the source database and never recovering automatically.
+    // We now instead jump straight to replication if the wal_status is not "lost", rather detecting those
+    // errors during streaming replication, which is a little more robust.
+
+    // We can have:
+    //   1. needsInitialSync: true, lost slot -> MissingReplicationSlotError (starts new sync rules version).
+    //      Theoretically we could handle this the same as (2).
+    //   2. needsInitialSync: true, no slot -> create new slot
+    //   3. needsInitialSync: true, valid slot -> resume initial sync
+    //   4. needsInitialSync: false, lost slot -> MissingReplicationSlotError (starts new sync rules version)
+    //   5. needsInitialSync: false, no slot -> MissingReplicationSlotError (starts new sync rules version)
+    //   6. needsInitialSync: false, valid slot -> resume streaming replication
+    // The main advantage of MissingReplicationSlotError are:
+    // 1. If there was a complete snapshot already (cases 4/5), users can still sync from that snapshot while
+    //    we do the reprocessing under a new slot name.
+    // 2. If there was a partial snapshot (case 1), we can start with the new slot faster by not waiting for
+    //    the partial data to be cleared.
     if (slot != null) {
       // This checks that the slot is still valid
-      const r = await this.checkReplicationSlot(slot as any);
-      if (snapshotDone && r.needsNewSlot) {
-        // We keep the current snapshot, and create a new replication slot
-        throw new MissingReplicationSlotError(`Replication slot ${slotName} is not valid anymore`);
+
+      // wal_status is present in postgres 13+
+      // invalidation_reason is present in postgres 17+
+      const lost = slot.wal_status == 'lost';
+      if (lost) {
+        // Case 1 / 4
+        throw new MissingReplicationSlotError(
+          `Replication slot ${slotName} is not valid anymore. invalidation_reason: ${slot.invalidation_reason ?? 'unknown'}`
+        );
       }
-      // We can have:
-      //   needsInitialSync: true, needsNewSlot: true -> initial sync from scratch
-      //   needsInitialSync: true, needsNewSlot: false -> resume initial sync
-      //   needsInitialSync: false, needsNewSlot: true -> handled above
-      //   needsInitialSync: false, needsNewSlot: false -> resume streaming replication
+      // Case 3 / 6
       return {
         needsInitialSync: !snapshotDone,
-        needsNewSlot: r.needsNewSlot
+        needsNewSlot: false
       };
     } else {
       if (snapshotDone) {
+        // Case 5
         // This will create a new slot, while keeping the current sync rules active
         throw new MissingReplicationSlotError(`Replication slot ${slotName} is missing`);
       }
-      // This will clear data and re-create the same slot
+      // Case 2
+      // This will clear data (if any) and re-create the same slot
       return { needsInitialSync: true, needsNewSlot: true };
     }
   }
 
-  /**
-   * If a replication slot exists, check that it is healthy.
-   */
-  private async checkReplicationSlot(slot: {
-    // postgres 13+
-    wal_status?: string;
-    // postgres 17+
-    invalidation_reason?: string | null;
-  }): Promise<{ needsNewSlot: boolean }> {
-    // Start with a placeholder error, should be replaced if there is an actual issue.
-    let last_error = new ReplicationAssertionError(`Slot health check failed to execute`);
-
-    const slotName = this.slot_name;
-
-    const lost = slot.wal_status == 'lost';
-    if (lost) {
-      this.logger.warn(
-        `Replication slot ${slotName} is invalidated. invalidation_reason: ${slot.invalidation_reason ?? 'unknown'}`
-      );
-      return {
-        needsNewSlot: true
-      };
-    }
-
-    // Check that replication slot exists, trying for up to 2 minutes.
-    const startAt = performance.now();
-    while (performance.now() - startAt < 120_000) {
-      this.touch();
-
-      try {
-        // We peek a large number of changes here, to make it more likely to pick up replication slot errors.
-        // For example, "publication does not exist" only occurs here if the peek actually includes changes related
-        // to the slot.
-        this.logger.info(`Checking ${slotName}`);
-
-        // The actual results can be quite large, so we don't actually return everything
-        // due to memory and processing overhead that would create.
-        const cursor = await this.connections.pool.stream({
-          statement: `SELECT 1 FROM pg_catalog.pg_logical_slot_peek_binary_changes($1, NULL, 1000, 'proto_version', '1', 'publication_names', $2)`,
-          params: [
-            { type: 'varchar', value: slotName },
-            { type: 'varchar', value: PUBLICATION_NAME }
-          ]
-        });
-
-        for await (let _chunk of cursor) {
-          // No-op, just exhaust the cursor
-        }
-
-        // Success
-        this.logger.info(`Slot ${slotName} appears healthy`);
-        return { needsNewSlot: false };
-      } catch (e) {
-        last_error = e;
-        this.logger.warn(`Replication slot error`, e);
-
-        if (this.stopped) {
-          throw e;
-        }
-
-        if (
-          /incorrect prev-link/.test(e.message) ||
-          /replication slot.*does not exist/.test(e.message) ||
-          /publication.*does not exist/.test(e.message) ||
-          // Postgres 18 - exceeded max_slot_wal_keep_size
-          /can no longer access replication slot/.test(e.message) ||
-          // Postgres 17 - exceeded max_slot_wal_keep_size
-          /can no longer get changes from replication slot/.test(e.message)
-        ) {
-          // Fatal error. In most cases since Postgres 13+, the `wal_status == 'lost'` check should pick this up, but this
-          // works as a fallback.
-
-          container.reporter.captureException(e, {
-            level: errors.ErrorSeverity.WARNING,
-            metadata: {
-              replication_slot: slotName
-            }
-          });
-          // Sample: record with incorrect prev-link 10000/10000 at 0/18AB778
-          //   Seen during development. Some internal error, fixed by re-creating slot.
-          //
-          // Sample: publication "powersync" does not exist
-          //   Happens when publication deleted or never created.
-          //   Slot must be re-created in this case.
-          this.logger.info(`${slotName} is not valid anymore`);
-
-          return { needsNewSlot: true };
-        }
-        // Try again after a pause
-        await new Promise((resolve) => setTimeout(resolve, 1000));
-      }
-    }
-
-    container.reporter.captureException(last_error, {
-      level: errors.ErrorSeverity.ERROR,
-      metadata: {
-        replication_slot: slotName
-      }
-    });
-
-    throw last_error;
-  }
-
   async estimatedCountNumber(db: pgwire.PgConnection, table: storage.SourceTable): Promise<number> {
     const results = await db.query({
       statement: `SELECT reltuples::bigint AS estimate
@@ -626,6 +546,7 @@ WHERE  oid = $1::regclass`,
     await q.initialize();
 
     let columns: { i: number; name: string }[] = [];
+    let columnMap: Record<string, number> = {};
     let hasRemainingData = true;
     while (hasRemainingData) {
       // Fetch 10k at a time.
@@ -645,6 +566,9 @@ WHERE  oid = $1::regclass`,
           columns = chunk.payload.map((c) => {
             return { i: i++, name: c.name };
           });
+          for (let column of chunk.payload) {
+            columnMap[column.name] = column.typeOid;
+          }
           continue;
         }
 
@@ -660,7 +584,7 @@ WHERE  oid = $1::regclass`,
         }
 
         for (const inputRecord of WalStream.getQueryData(rows)) {
-          const record = this.syncRulesRecord(inputRecord);
+          const record = this.syncRulesRecord(this.connections.types.constructRowRecord(columnMap, inputRecord));
           // This auto-flushes when the batch reaches its size limit
           await batch.save({
             tag: storage.SaveOperationTag.INSERT,
@@ -915,6 +839,17 @@ WHERE  oid = $1::regclass`,
   }
 
   async streamChanges(replicationConnection: pgwire.PgConnection) {
+    try {
+      await this.streamChangesInternal(replicationConnection);
+    } catch (e) {
+      if (isReplicationSlotInvalidError(e)) {
+        throw new MissingReplicationSlotError(e.message, e);
+      }
+      throw e;
+    }
+  }
+
+  private async streamChangesInternal(replicationConnection: pgwire.PgConnection) {
     // When changing any logic here, check /docs/wal-lsns.md.
     const { createEmptyCheckpoints } = await this.ensureStorageCompatibility();
 
@@ -1179,3 +1114,27 @@ WHERE  oid = $1::regclass`,
     });
   }
 }
+
+function isReplicationSlotInvalidError(e: any) {
+  // We could access the error code from pgwire using this:
+  //   e[Symbol.for('pg.ErrorCode')]
+  // However, we typically get a generic code such as 42704 (undefined_object), which does not
+  // help much. So we check the actual error message.
+  const message = e.message ?? '';
+
+  // Sample: record with incorrect prev-link 10000/10000 at 0/18AB778
+  //   Seen during development. Some internal error, fixed by re-creating slot.
+  //
+  // Sample: publication "powersync" does not exist
+  //   Happens when publication deleted or never created.
+  //   Slot must be re-created in this case.
+  return (
+    /incorrect prev-link/.test(message) ||
+    /replication slot.*does not exist/.test(message) ||
+    /publication.*does not exist/.test(message) ||
+    // Postgres 18 - exceeded max_slot_wal_keep_size
+    /can no longer access replication slot/.test(message) ||
+    // Postgres 17 - exceeded max_slot_wal_keep_size
+    /can no longer get changes from replication slot/.test(message)
+  );
+}

package/src/replication/WalStreamReplicationJob.ts

@@ -12,19 +12,13 @@ export interface WalStreamReplicationJobOptions extends replication.AbstractRepl
 
 export class WalStreamReplicationJob extends replication.AbstractReplicationJob {
   private connectionFactory: ConnectionManagerFactory;
-  private readonly connectionManager: PgManager;
+  private connectionManager: PgManager | null = null;
   private lastStream: WalStream | null = null;
 
   constructor(options: WalStreamReplicationJobOptions) {
     super(options);
     this.logger = logger.child({ prefix: `[${this.slotName}] ` });
     this.connectionFactory = options.connectionFactory;
-    this.connectionManager = this.connectionFactory.create({
-      // Pool connections are only used intermittently.
-      idleTimeout: 30_000,
-      maxSize: 2,
-      applicationName: getApplicationName()
-    });
   }
 
   /**
@@ -40,10 +34,12 @@ export class WalStreamReplicationJob extends replication.AbstractReplicationJob
    * **This may be a bug in pgwire or how we're using it.
    */
   async keepAlive() {
-    try {
-      await sendKeepAlive(this.connectionManager.pool);
-    } catch (e) {
-      this.logger.warn(`KeepAlive failed, unable to post to WAL`, e);
+    if (this.connectionManager) {
+      try {
+        await sendKeepAlive(this.connectionManager.pool);
+      } catch (e) {
+        this.logger.warn(`KeepAlive failed, unable to post to WAL`, e);
+      }
     }
   }
 
@@ -53,35 +49,58 @@ export class WalStreamReplicationJob extends replication.AbstractReplicationJob
 
   async replicate() {
     try {
-      await this.replicateLoop();
+      await this.replicateOnce();
     } catch (e) {
       // Fatal exception
-      container.reporter.captureException(e, {
-        metadata: {
-          replication_slot: this.slotName
+
+      if (!this.isStopped) {
+        // Ignore aborted errors
+
+        this.logger.error(`Replication error`, e);
+        if (e.cause != null) {
+          // Example:
+          // PgError.conn_ended: Unable to do postgres query on ended connection
+          //     at PgConnection.stream (file:///.../powersync/node_modules/.pnpm/github.com+kagis+pgwire@f1cb95f9a0f42a612bb5a6b67bb2eb793fc5fc87/node_modules/pgwire/mod.js:315:13)
+          //     at stream.next (<anonymous>)
+          //     at PgResult.fromStream (file:///.../powersync/node_modules/.pnpm/github.com+kagis+pgwire@f1cb95f9a0f42a612bb5a6b67bb2eb793fc5fc87/node_modules/pgwire/mod.js:1174:22)
+          //     at PgConnection.query (file:///.../powersync/node_modules/.pnpm/github.com+kagis+pgwire@f1cb95f9a0f42a612bb5a6b67bb2eb793fc5fc87/node_modules/pgwire/mod.js:311:21)
+          //     at WalStream.startInitialReplication (file:///.../powersync/powersync-service/lib/replication/WalStream.js:266:22)
+          //     ...
+          //   cause: TypeError: match is not iterable
+          //       at timestamptzToSqlite (file:///.../powersync/packages/jpgwire/dist/util.js:140:50)
+          //       at PgType.decode (file:///.../powersync/packages/jpgwire/dist/pgwire_types.js:25:24)
+          //       at PgConnection._recvDataRow (file:///.../powersync/packages/jpgwire/dist/util.js:88:22)
+          //       at PgConnection._recvMessages (file:///.../powersync/node_modules/.pnpm/github.com+kagis+pgwire@f1cb95f9a0f42a612bb5a6b67bb2eb793fc5fc87/node_modules/pgwire/mod.js:656:30)
+          //       at PgConnection._ioloopAttempt (file:///.../powersync/node_modules/.pnpm/github.com+kagis+pgwire@f1cb95f9a0f42a612bb5a6b67bb2eb793fc5fc87/node_modules/pgwire/mod.js:563:20)
+          //       at process.processTicksAndRejections (node:internal/process/task_queues:95:5)
+          //       at async PgConnection._ioloop (file:///.../powersync/node_modules/.pnpm/github.com+kagis+pgwire@f1cb95f9a0f42a612bb5a6b67bb2eb793fc5fc87/node_modules/pgwire/mod.js:517:14),
+          //   [Symbol(pg.ErrorCode)]: 'conn_ended',
+          //   [Symbol(pg.ErrorResponse)]: undefined
+          // }
+          // Without this additional log, the cause would not be visible in the logs.
+          this.logger.error(`cause`, e.cause);
         }
-      });
-      this.logger.error(`Replication failed`, e);
+        // Report the error if relevant, before retrying
+        container.reporter.captureException(e, {
+          metadata: {
+            replication_slot: this.slotName
+          }
+        });
+        // This sets the retry delay
+        this.rateLimiter.reportError(e);
+      }
 
       if (e instanceof MissingReplicationSlotError) {
         // This stops replication on this slot and restarts with a new slot
         await this.options.storage.factory.restartReplication(this.storage.group_id);
       }
+
+      // No need to rethrow - the error is already logged, and retry behavior is the same on error
     } finally {
       this.abortController.abort();
     }
   }
 
-  async replicateLoop() {
-    while (!this.isStopped) {
-      await this.replicateOnce();
-
-      if (!this.isStopped) {
-        await new Promise((resolve) => setTimeout(resolve, 5000));
-      }
-    }
-  }
-
   async replicateOnce() {
     // New connections on every iteration (every error with retry),
     // otherwise we risk repeating errors related to the connection,
@@ -92,6 +111,7 @@ export class WalStreamReplicationJob extends replication.AbstractReplicationJob
       maxSize: 2,
       applicationName: getApplicationName()
     });
+    this.connectionManager = connectionManager;
     try {
       await this.rateLimiter?.waitUntilAllowed({ signal: this.abortController.signal });
       if (this.isStopped) {
@@ -106,48 +126,8 @@ export class WalStreamReplicationJob extends replication.AbstractReplicationJob
       });
       this.lastStream = stream;
       await stream.replicate();
-    } catch (e) {
-      if (this.isStopped && e instanceof ReplicationAbortedError) {
-        // Ignore aborted errors
-        return;
-      }
-      this.logger.error(`Replication error`, e);
-      if (e.cause != null) {
-        // Example:
-        // PgError.conn_ended: Unable to do postgres query on ended connection
-        //     at PgConnection.stream (file:///.../powersync/node_modules/.pnpm/github.com+kagis+pgwire@f1cb95f9a0f42a612bb5a6b67bb2eb793fc5fc87/node_modules/pgwire/mod.js:315:13)
-        //     at stream.next (<anonymous>)
-        //     at PgResult.fromStream (file:///.../powersync/node_modules/.pnpm/github.com+kagis+pgwire@f1cb95f9a0f42a612bb5a6b67bb2eb793fc5fc87/node_modules/pgwire/mod.js:1174:22)
-        //     at PgConnection.query (file:///.../powersync/node_modules/.pnpm/github.com+kagis+pgwire@f1cb95f9a0f42a612bb5a6b67bb2eb793fc5fc87/node_modules/pgwire/mod.js:311:21)
-        //     at WalStream.startInitialReplication (file:///.../powersync/powersync-service/lib/replication/WalStream.js:266:22)
-        //     ...
-        //   cause: TypeError: match is not iterable
-        //       at timestamptzToSqlite (file:///.../powersync/packages/jpgwire/dist/util.js:140:50)
-        //       at PgType.decode (file:///.../powersync/packages/jpgwire/dist/pgwire_types.js:25:24)
-        //       at PgConnection._recvDataRow (file:///.../powersync/packages/jpgwire/dist/util.js:88:22)
-        //       at PgConnection._recvMessages (file:///.../powersync/node_modules/.pnpm/github.com+kagis+pgwire@f1cb95f9a0f42a612bb5a6b67bb2eb793fc5fc87/node_modules/pgwire/mod.js:656:30)
-        //       at PgConnection._ioloopAttempt (file:///.../powersync/node_modules/.pnpm/github.com+kagis+pgwire@f1cb95f9a0f42a612bb5a6b67bb2eb793fc5fc87/node_modules/pgwire/mod.js:563:20)
-        //       at process.processTicksAndRejections (node:internal/process/task_queues:95:5)
-        //       at async PgConnection._ioloop (file:///.../powersync/node_modules/.pnpm/github.com+kagis+pgwire@f1cb95f9a0f42a612bb5a6b67bb2eb793fc5fc87/node_modules/pgwire/mod.js:517:14),
-        //   [Symbol(pg.ErrorCode)]: 'conn_ended',
-        //   [Symbol(pg.ErrorResponse)]: undefined
-        // }
-        // Without this additional log, the cause would not be visible in the logs.
-        this.logger.error(`cause`, e.cause);
-      }
-      if (e instanceof MissingReplicationSlotError) {
-        throw e;
-      } else {
-        // Report the error if relevant, before retrying
-        container.reporter.captureException(e, {
-          metadata: {
-            replication_slot: this.slotName
-          }
-        });
-        // This sets the retry delay
-        this.rateLimiter?.reportError(e);
-      }
     } finally {
+      this.connectionManager = null;
       await connectionManager.end();
     }
   }

package/src/types/resolver.ts

@@ -1,8 +1,8 @@
-import { DatabaseInputRow, SqliteInputRow, toSyncRulesRow } from '@powersync/service-sync-rules';
 import * as pgwire from '@powersync/service-jpgwire';
-import { CustomTypeRegistry } from './registry.js';
+import { DatabaseInputRow, SqliteInputRow, toSyncRulesRow } from '@powersync/service-sync-rules';
 import semver from 'semver';
 import { getServerVersion } from '../utils/postgres_version.js';
+import { CustomTypeRegistry } from './registry.js';
 
 /**
  * Resolves descriptions used to decode values for custom postgres types.
@@ -11,11 +11,9 @@ import { getServerVersion } from '../utils/postgres_version.js';
  */
 export class PostgresTypeResolver {
   private cachedVersion: semver.SemVer | null = null;
+  readonly registry: CustomTypeRegistry;
 
-  constructor(
-    readonly registry: CustomTypeRegistry,
-    private readonly pool: pgwire.PgClient
-  ) {
+  constructor(private readonly pool: pgwire.PgClient) {
     this.registry = new CustomTypeRegistry();
   }
 
@@ -188,6 +186,11 @@ WHERE a.attnum > 0
     return toSyncRulesRow(record);
   }
 
+  constructRowRecord(columnMap: Record<string, number>, tupleRaw: Record<string, any>): SqliteInputRow {
+    const record = this.decodeTupleForTable(columnMap, tupleRaw);
+    return toSyncRulesRow(record);
+  }
+
   /**
    * We need a high level of control over how values are decoded, to make sure there is no loss
    * of precision in the process.
@@ -206,5 +209,23 @@ WHERE a.attnum > 0
     return result;
   }
 
+  /**
+   * We need a high level of control over how values are decoded, to make sure there is no loss
+   * of precision in the process.
+   */
+  private decodeTupleForTable(columnMap: Record<string, number>, tupleRaw: Record<string, any>): DatabaseInputRow {
+    let result: Record<string, any> = {};
+    for (let columnName in tupleRaw) {
+      const rawval = tupleRaw[columnName];
+      const typeOid = columnMap[columnName];
+      if (typeof rawval == 'string' && typeOid) {
+        result[columnName] = this.registry.decodeDatabaseValue(rawval, typeOid);
+      } else {
+        result[columnName] = rawval;
+      }
+    }
+    return result;
+  }
+
   private static minVersionForMultirange: semver.SemVer = semver.parse('14.0.0')!;
 }

package/src/types/types.ts

@@ -1,7 +1,6 @@
 import * as lib_postgres from '@powersync/lib-service-postgres';
 import * as service_types from '@powersync/service-types';
 import * as t from 'ts-codec';
-import { CustomTypeRegistry } from './registry.js';
 
 // Maintain backwards compatibility by exporting these
 export const validatePort = lib_postgres.validatePort;
@@ -25,10 +24,7 @@ export type PostgresConnectionConfig = t.Decoded<typeof PostgresConnectionConfig
 /**
  * Resolved version of {@link PostgresConnectionConfig}
  */
-export type ResolvedConnectionConfig = PostgresConnectionConfig &
-  NormalizedPostgresConnectionConfig & {
-    typeRegistry: CustomTypeRegistry;
-  };
+export type ResolvedConnectionConfig = PostgresConnectionConfig & NormalizedPostgresConnectionConfig;
 
 export function isPostgresConfig(
   config: service_types.configFile.DataSourceConfig