@powersync/service-module-postgres 0.0.0-dev-20250117095455 → 0.0.0-dev-20250214100224

package/package.json

@@ -5,7 +5,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.0.0-dev-20250117095455",
+  "version": "0.0.0-dev-20250214100224",
   "main": "dist/index.js",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",
@@ -22,24 +22,26 @@
     }
   },
   "dependencies": {
-    "pgwire": "github:kagis/pgwire#f1cb95f9a0f42a612bb5a6b67bb2eb793fc5fc87",
     "jose": "^4.15.1",
+    "pgwire": "github:kagis/pgwire#f1cb95f9a0f42a612bb5a6b67bb2eb793fc5fc87",
+    "semver": "^7.5.4",
     "ts-codec": "^1.3.0",
-    "uuid": "^9.0.1",
     "uri-js": "^4.4.1",
-    "@powersync/lib-services-framework": "0.0.0-dev-20250117095455",
-    "@powersync/lib-service-postgres": "0.0.0-dev-20250117095455",
-    "@powersync/service-core": "0.0.0-dev-20250117095455",
-    "@powersync/service-jpgwire": "0.0.0-dev-20250117095455",
+    "uuid": "^9.0.1",
+    "@powersync/lib-service-postgres": "0.3.1",
+    "@powersync/lib-services-framework": "0.5.1",
+    "@powersync/service-core": "0.0.0-dev-20250214100224",
+    "@powersync/service-jpgwire": "0.19.0",
     "@powersync/service-jsonbig": "0.17.10",
-    "@powersync/service-sync-rules": "0.23.1",
-    "@powersync/service-types": "0.0.0-dev-20250117095455"
+    "@powersync/service-sync-rules": "0.23.4",
+    "@powersync/service-types": "0.8.0"
   },
   "devDependencies": {
+    "@types/semver": "^7.5.4",
     "@types/uuid": "^9.0.4",
-    "@powersync/service-core-tests": "0.0.0-dev-20250117095455",
-    "@powersync/service-module-mongodb-storage": "0.0.0-dev-20250117095455",
-    "@powersync/service-module-postgres-storage": "0.0.0-dev-20250117095455"
+    "@powersync/service-core-tests": "0.0.0-dev-20250214100224",
+    "@powersync/service-module-mongodb-storage": "0.0.0-dev-20250214100224",
+    "@powersync/service-module-postgres-storage": "0.0.0-dev-20250214100224"
   },
   "scripts": {
     "build": "tsc -b",

package/src/api/PostgresRouteAPIAdapter.ts

@@ -1,11 +1,12 @@
 import * as lib_postgres from '@powersync/lib-service-postgres';
-import { api, ParseSyncRulesOptions } from '@powersync/service-core';
+import { ErrorCode, ServiceError } from '@powersync/lib-services-framework';
+import { api, ParseSyncRulesOptions, ReplicationHeadCallback } from '@powersync/service-core';
 import * as pgwire from '@powersync/service-jpgwire';
 import * as sync_rules from '@powersync/service-sync-rules';
 import * as service_types from '@powersync/service-types';
 import * as replication_utils from '../replication/replication-utils.js';
 import { getDebugTableInfo } from '../replication/replication-utils.js';
-import { PUBLICATION_NAME } from '../replication/WalStream.js';
+import { KEEPALIVE_STATEMENT, PUBLICATION_NAME } from '../replication/WalStream.js';
 import * as types from '../types/types.js';
 
 export class PostgresRouteAPIAdapter implements api.RouteAPI {
@@ -228,7 +229,11 @@ FROM pg_replication_slots WHERE slot_name = $1 LIMIT 1;`,
       return Number(row.lsn_distance);
     }
 
-    throw new Error(`Could not determine replication lag for slot ${slotName}`);
+    throw new ServiceError({
+      status: 500,
+      code: ErrorCode.PSYNC_S4001,
+      description: `Could not determine replication lag for slot ${slotName}`
+    });
   }
 
   async getReplicationHead(): Promise<string> {
@@ -236,17 +241,22 @@ FROM pg_replication_slots WHERE slot_name = $1 LIMIT 1;`,
     // However, on Aurora (Postgres compatible), it can return an entirely different LSN,
     // causing the write checkpoints to never be replicated back to the client.
     // For those, we need to use pg_current_wal_lsn() instead.
-    const { results } = await lib_postgres.retriedQuery(
-      this.pool,
-      { statement: `SELECT pg_current_wal_lsn() as lsn` },
-      { statement: `SELECT pg_logical_emit_message(false, 'powersync', 'ping')` }
-    );
+    const { results } = await lib_postgres.retriedQuery(this.pool, `SELECT pg_current_wal_lsn() as lsn`);
 
-    // Specifically use the lsn from the first statement, not the second one.
     const lsn = results[0].rows[0][0];
     return String(lsn);
   }
 
+  async createReplicationHead<T>(callback: ReplicationHeadCallback<T>): Promise<T> {
+    const currentLsn = await this.getReplicationHead();
+
+    const r = await callback(currentLsn);
+
+    await lib_postgres.retriedQuery(this.pool, KEEPALIVE_STATEMENT);
+
+    return r;
+  }
+
   async getConnectionSchema(): Promise<service_types.DatabaseSchema[]> {
     // https://github.com/Borvik/vscode-postgres/blob/88ec5ed061a0c9bced6c5d4ec122d0759c3f3247/src/language/server.ts
     const results = await lib_postgres.retriedQuery(

package/src/module/PostgresModule.ts

@@ -1,4 +1,12 @@
-import { api, auth, ConfigurationFileSyncRulesProvider, modules, replication, system } from '@powersync/service-core';
+import {
+  api,
+  auth,
+  ConfigurationFileSyncRulesProvider,
+  ConnectionTestResult,
+  modules,
+  replication,
+  system
+} from '@powersync/service-core';
 import * as jpgwire from '@powersync/service-jpgwire';
 import { PostgresRouteAPIAdapter } from '../api/PostgresRouteAPIAdapter.js';
 import { SupabaseKeyCollector } from '../auth/SupabaseKeyCollector.js';
@@ -10,6 +18,7 @@ import { PUBLICATION_NAME } from '../replication/WalStream.js';
 import { WalStreamReplicator } from '../replication/WalStreamReplicator.js';
 import * as types from '../types/types.js';
 import { PostgresConnectionConfig } from '../types/types.js';
+import { baseUri, NormalizedBasePostgresConnectionConfig } from '@powersync/lib-service-postgres';
 
 export class PostgresModule extends replication.ReplicationModule<types.PostgresConnectionConfig> {
   constructor() {
@@ -124,18 +133,26 @@ export class PostgresModule extends replication.ReplicationModule<types.Postgres
       });
   }
 
-  async testConnection(config: PostgresConnectionConfig): Promise<void> {
+  async testConnection(config: PostgresConnectionConfig): Promise<ConnectionTestResult> {
     this.decodeConfig(config);
-    const normalisedConfig = this.resolveConfig(this.decodedConfig!);
-    const connectionManager = new PgManager(normalisedConfig, {
+    const normalizedConfig = this.resolveConfig(this.decodedConfig!);
+    return await this.testConnection(normalizedConfig);
+  }
+
+  static async testConnection(normalizedConfig: NormalizedBasePostgresConnectionConfig): Promise<ConnectionTestResult> {
+    // FIXME: This is not a complete implementation yet.
+    const connectionManager = new PgManager(normalizedConfig, {
       idleTimeout: 30_000,
       maxSize: 1
     });
     const connection = await connectionManager.snapshotConnection();
     try {
-      return await checkSourceConfiguration(connection, PUBLICATION_NAME);
+      await checkSourceConfiguration(connection, PUBLICATION_NAME);
     } finally {
       await connectionManager.end();
     }
+    return {
+      connectionDescription: baseUri(normalizedConfig)
+    };
   }
 }

package/src/replication/ConnectionManagerFactory.ts

@@ -5,7 +5,7 @@ import { logger } from '@powersync/lib-services-framework';
 
 export class ConnectionManagerFactory {
   private readonly connectionManagers: PgManager[];
-  private readonly dbConnectionConfig: NormalizedPostgresConnectionConfig;
+  public readonly dbConnectionConfig: NormalizedPostgresConnectionConfig;
 
   constructor(dbConnectionConfig: NormalizedPostgresConnectionConfig) {
     this.dbConnectionConfig = dbConnectionConfig;

package/src/replication/PgManager.ts

@@ -1,4 +1,5 @@
 import * as pgwire from '@powersync/service-jpgwire';
+import semver from 'semver';
 import { NormalizedPostgresConnectionConfig } from '../types/types.js';
 
 /**
@@ -35,6 +36,15 @@ export class PgManager {
     return await p;
   }
 
+  /**
+   * @returns The Postgres server version in a parsed Semver instance
+   */
+  async getServerVersion(): Promise<semver.SemVer | null> {
+    const result = await this.pool.query(`SHOW server_version;`);
+    // The result is usually of the form "16.2 (Debian 16.2-1.pgdg120+2)"
+    return semver.coerce(result.rows[0][0].split(' ')[0]);
+  }
+
   /**
    * Create a new standard connection, used for initial snapshot.
    *

package/src/replication/PgRelation.ts

@@ -1,3 +1,4 @@
+import { ReplicationAssertionError, ServiceError } from '@powersync/lib-services-framework';
 import { storage } from '@powersync/service-core';
 import { PgoutputRelation } from '@powersync/service-jpgwire';
 
@@ -16,7 +17,7 @@ export function getRelId(source: PgoutputRelation): number {
   // Source types are wrong here
   const relId = (source as any).relationOid as number;
   if (!relId) {
-    throw new Error(`No relation id!`);
+    throw new ReplicationAssertionError(`No relation id found`);
   }
   return relId;
 }

package/src/replication/WalStream.ts

@@ -1,5 +1,13 @@
 import * as lib_postgres from '@powersync/lib-service-postgres';
-import { container, errors, logger } from '@powersync/lib-services-framework';
+import {
+  container,
+  DatabaseConnectionError,
+  ErrorCode,
+  errors,
+  logger,
+  ReplicationAbortedError,
+  ReplicationAssertionError
+} from '@powersync/lib-services-framework';
 import { getUuidReplicaIdentityBson, Metrics, SourceEntityDescriptor, storage } from '@powersync/service-core';
 import * as pgwire from '@powersync/service-jpgwire';
 import { DatabaseInputRow, SqliteRow, SqlSyncRules, TablePattern, toSyncRulesRow } from '@powersync/service-sync-rules';
@@ -9,10 +17,6 @@ import { PgManager } from './PgManager.js';
 import { getPgOutputRelation, getRelId } from './PgRelation.js';
 import { checkSourceConfiguration, getReplicationIdentityColumns } from './replication-utils.js';
 
-export const ZERO_LSN = '00000000/00000000';
-export const PUBLICATION_NAME = 'powersync';
-export const POSTGRES_DEFAULT_SCHEMA = 'public';
-
 export interface WalStreamOptions {
   connections: PgManager;
   storage: storage.SyncRulesBucketStorage;
@@ -26,6 +30,35 @@ interface InitResult {
   needsNewSlot: boolean;
 }
 
+export const ZERO_LSN = '00000000/00000000';
+export const PUBLICATION_NAME = 'powersync';
+export const POSTGRES_DEFAULT_SCHEMA = 'public';
+
+export const KEEPALIVE_CONTENT = 'ping';
+export const KEEPALIVE_BUFFER = Buffer.from(KEEPALIVE_CONTENT);
+export const KEEPALIVE_STATEMENT: pgwire.Statement = {
+  statement: /* sql */ `
+    SELECT
+      *
+    FROM
+      pg_logical_emit_message(FALSE, 'powersync', $1)
+  `,
+  params: [{ type: 'varchar', value: KEEPALIVE_CONTENT }]
+} as const;
+
+export const isKeepAliveMessage = (msg: pgwire.PgoutputMessage) => {
+  return (
+    msg.tag == 'message' &&
+    msg.prefix == 'powersync' &&
+    msg.content &&
+    Buffer.from(msg.content).equals(KEEPALIVE_BUFFER)
+  );
+};
+
+export const sendKeepAlive = async (db: pgwire.PgClient) => {
+  await lib_postgres.retriedQuery(db, KEEPALIVE_STATEMENT);
+};
+
 export class MissingReplicationSlotError extends Error {
   constructor(message: string) {
     super(message);
@@ -65,10 +98,7 @@ export class WalStream {
           // Ping to speed up cancellation of streaming replication
           // We're not using pg_snapshot here, since it could be in the middle of
           // an initial replication transaction.
-          const promise = lib_postgres.retriedQuery(
-            this.connections.pool,
-            `SELECT * FROM pg_logical_emit_message(false, 'powersync', 'ping')`
-          );
+          const promise = sendKeepAlive(this.connections.pool);
           promise.catch((e) => {
             // Failures here are okay - this only speeds up stopping the process.
             logger.warn('Failed to ping connection', e);
@@ -133,7 +163,7 @@ export class WalStream {
     for (let row of tableRows) {
       const name = row.table_name as string;
       if (typeof row.relid != 'bigint') {
-        throw new Error(`missing relid for ${name}`);
+        throw new ReplicationAssertionError(`Missing relid for ${name}`);
       }
       const relid = Number(row.relid as bigint);
 
@@ -174,6 +204,7 @@ export class WalStream {
 
   async initSlot(): Promise<InitResult> {
     await checkSourceConfiguration(this.connections.pool, PUBLICATION_NAME);
+    await this.ensureStorageCompatibility();
 
     const slotName = this.slot_name;
 
@@ -294,7 +325,7 @@ export class WalStream {
       }
     }
 
-    throw new Error('Unreachable');
+    throw new ReplicationAssertionError('Unreachable');
   }
 
   async estimatedCount(db: pgwire.PgConnection, table: storage.SourceTable): Promise<string> {
@@ -376,6 +407,15 @@ WHERE  oid = $1::regclass`,
         await batch.commit(ZERO_LSN);
       }
     );
+    /**
+     * Send a keepalive message after initial replication.
+     * In some edge cases we wait for a keepalive after the initial snapshot.
+     * If we don't explicitly check the contents of keepalive messages then a keepalive is detected
+     * rather quickly after initial replication - perhaps due to other WAL events.
+     * If we do explicitly check the contents of messages, we need an actual keepalive payload in order
+     * to advance the active sync rules LSN.
+     */
+    await sendKeepAlive(db);
   }
 
   static *getQueryData(results: Iterable<DatabaseInputRow>): Generator<SqliteRow> {
@@ -415,7 +455,7 @@ WHERE  oid = $1::regclass`,
         lastLogIndex = at;
       }
       if (this.abort_signal.aborted) {
-        throw new Error(`Aborted initial replication of ${this.slot_name}`);
+        throw new ReplicationAbortedError(`Aborted initial replication of ${this.slot_name}`);
       }
 
       for (const record of WalStream.getQueryData(rows)) {
@@ -441,7 +481,7 @@ WHERE  oid = $1::regclass`,
 
   async handleRelation(batch: storage.BucketStorageBatch, descriptor: SourceEntityDescriptor, snapshot: boolean) {
     if (!descriptor.objectId && typeof descriptor.objectId != 'number') {
-      throw new Error('objectId expected');
+      throw new ReplicationAssertionError(`objectId expected, got ${typeof descriptor.objectId}`);
     }
     const result = await this.storage.resolveTable({
       group_id: this.group_id,
@@ -484,6 +524,7 @@ WHERE  oid = $1::regclass`,
           await db.query('COMMIT');
         } catch (e) {
           await db.query('ROLLBACK');
+          // TODO: Wrap with custom error type
           throw e;
         }
       } finally {
@@ -501,7 +542,7 @@ WHERE  oid = $1::regclass`,
     if (table == null) {
       // We should always receive a replication message before the relation is used.
       // If we can't find it, it's a bug.
-      throw new Error(`Missing relation cache for ${relationId}`);
+      throw new ReplicationAssertionError(`Missing relation cache for ${relationId}`);
     }
     return table;
   }
@@ -592,13 +633,33 @@ WHERE  oid = $1::regclass`,
   async streamChanges(replicationConnection: pgwire.PgConnection) {
     // When changing any logic here, check /docs/wal-lsns.md.
 
+    const { createEmptyCheckpoints } = await this.ensureStorageCompatibility();
+
+    const replicationOptions: Record<string, string> = {
+      proto_version: '1',
+      publication_names: PUBLICATION_NAME
+    };
+
+    /**
+     * Viewing the contents of logical messages emitted with `pg_logical_emit_message`
+     * is only supported on Postgres >= 14.0.
+     * https://www.postgresql.org/docs/14/protocol-logical-replication.html
+     */
+    const exposesLogicalMessages = await this.checkLogicalMessageSupport();
+    if (exposesLogicalMessages) {
+      /**
+       * Only add this option if the Postgres server supports it.
+       * Adding the option to a server that doesn't support it will throw an exception when starting logical replication.
+       * Error: `unrecognized pgoutput option: messages`
+       */
+      replicationOptions['messages'] = 'true';
+    }
+
     const replicationStream = replicationConnection.logicalReplication({
       slot: this.slot_name,
-      options: {
-        proto_version: '1',
-        publication_names: PUBLICATION_NAME
-      }
+      options: replicationOptions
     });
+
     this.startedStreaming = true;
 
     // Auto-activate as soon as initial replication is done
@@ -621,6 +682,15 @@ WHERE  oid = $1::regclass`,
           // chunkLastLsn may come from normal messages in the chunk,
           // or from a PrimaryKeepalive message.
           const { messages, lastLsn: chunkLastLsn } = chunk;
+
+          /**
+           * We can check if an explicit keepalive was sent if `exposesLogicalMessages == true`.
+           * If we can't check the logical messages, we should assume a keepalive if we
+           * receive an empty array of messages in a replication event.
+           */
+          const assumeKeepAlive = !exposesLogicalMessages;
+          let keepAliveDetected = false;
+
           for (const msg of messages) {
             if (msg.tag == 'relation') {
               await this.handleRelation(batch, getPgOutputRelation(msg), true);
@@ -629,27 +699,44 @@ WHERE  oid = $1::regclass`,
             } else if (msg.tag == 'commit') {
               Metrics.getInstance().transactions_replicated_total.add(1);
               inTx = false;
-              await batch.commit(msg.lsn!);
+              await batch.commit(msg.lsn!, { createEmptyCheckpoints });
               await this.ack(msg.lsn!, replicationStream);
             } else {
               if (count % 100 == 0) {
                 logger.info(`${this.slot_name} replicating op ${count} ${msg.lsn}`);
               }
 
+              /**
+               * If we can see the contents of logical messages, then we can check if a keepalive
+               * message is present. We only perform a keepalive (below) if we explicitly detect a keepalive message.
+               * If we can't see the contents of logical messages, then we should assume a keepalive is required
+               * due to the default value of `assumeKeepalive`.
+               */
+              if (exposesLogicalMessages && isKeepAliveMessage(msg)) {
+                keepAliveDetected = true;
+              }
+
               count += 1;
               await this.writeChange(batch, msg);
             }
           }
 
           if (!inTx) {
-            // In a transaction, we ack and commit according to the transaction progress.
-            // Outside transactions, we use the PrimaryKeepalive messages to advance progress.
-            // Big caveat: This _must not_ be used to skip individual messages, since this LSN
-            // may be in the middle of the next transaction.
-            // It must only be used to associate checkpoints with LSNs.
-            if (await batch.keepalive(chunkLastLsn)) {
-              await this.ack(chunkLastLsn, replicationStream);
+            if (assumeKeepAlive || keepAliveDetected) {
+              // Reset the detection flag.
+              keepAliveDetected = false;
+
+              // In a transaction, we ack and commit according to the transaction progress.
+              // Outside transactions, we use the PrimaryKeepalive messages to advance progress.
+              // Big caveat: This _must not_ be used to skip individual messages, since this LSN
+              // may be in the middle of the next transaction.
+              // It must only be used to associate checkpoints with LSNs.
+              await batch.keepalive(chunkLastLsn);
             }
+
+            // We receive chunks with empty messages often (about each second).
+            // Acknowledging here progresses the slot past these and frees up resources.
+            await this.ack(chunkLastLsn, replicationStream);
           }
 
           Metrics.getInstance().chunks_replicated_total.add(1);
@@ -665,6 +752,53 @@ WHERE  oid = $1::regclass`,
 
     replicationStream.ack(lsn);
   }
+
+  /**
+   * Ensures that the storage is compatible with the replication connection.
+   * @throws {DatabaseConnectionError} If the storage is not compatible with the replication connection.
+   */
+  protected async ensureStorageCompatibility(): Promise<storage.ResolvedBucketBatchCommitOptions> {
+    const supportsLogicalMessages = await this.checkLogicalMessageSupport();
+
+    const storageIdentifier = await this.storage.factory.getSystemIdentifier();
+    if (storageIdentifier.type != lib_postgres.POSTGRES_CONNECTION_TYPE) {
+      return {
+        // Keep the same behaviour as before allowing Postgres storage.
+        createEmptyCheckpoints: true
+      };
+    }
+
+    const parsedStorageIdentifier = lib_postgres.utils.decodePostgresSystemIdentifier(storageIdentifier.id);
+    /**
+     * Check if the same server is being used for both the sync bucket storage and the logical replication.
+     */
+    const replicationIdentifier = await lib_postgres.utils.queryPostgresSystemIdentifier(this.connections.pool);
+
+    if (!supportsLogicalMessages && replicationIdentifier.server_id == parsedStorageIdentifier.server_id) {
+      throw new DatabaseConnectionError(
+        ErrorCode.PSYNC_S1144,
+        `Separate Postgres servers are required for the replication source and sync bucket storage when using Postgres versions below 14.0.`,
+        new Error('Postgres version is below 14')
+      );
+    }
+
+    return {
+      /**
+       * Don't create empty checkpoints if the same Postgres database is used for the data source
+       * and sync bucket storage. Creating empty checkpoints will cause WAL feedback loops.
+       */
+      createEmptyCheckpoints: replicationIdentifier.database_name != parsedStorageIdentifier.database_name
+    };
+  }
+
+  /**
+   * Check if the replication connection Postgres server supports
+   * viewing the contents of logical replication messages.
+   */
+  protected async checkLogicalMessageSupport() {
+    const version = await this.connections.getServerVersion();
+    return version ? version.compareMain('14.0.0') >= 0 : false;
+  }
 }
 
 async function touch() {

package/src/replication/WalStreamReplicationJob.ts

@@ -1,6 +1,6 @@
 import { container } from '@powersync/lib-services-framework';
 import { PgManager } from './PgManager.js';
-import { MissingReplicationSlotError, WalStream } from './WalStream.js';
+import { MissingReplicationSlotError, sendKeepAlive, WalStream } from './WalStream.js';
 
 import { replication } from '@powersync/service-core';
 import { ConnectionManagerFactory } from './ConnectionManagerFactory.js';
@@ -37,7 +37,7 @@ export class WalStreamReplicationJob extends replication.AbstractReplicationJob
    */
   async keepAlive() {
     try {
-      await this.connectionManager.pool.query(`SELECT * FROM pg_logical_emit_message(false, 'powersync', 'ping')`);
+      await sendKeepAlive(this.connectionManager.pool);
     } catch (e) {
       this.logger.warn(`KeepAlive failed, unable to post to WAL`, e);
     }
@@ -99,7 +99,7 @@ export class WalStreamReplicationJob extends replication.AbstractReplicationJob
       });
       await stream.replicate();
     } catch (e) {
-      this.logger.error(`Replication error`, e);
+      this.logger.error(`${this.slotName} Replication error`, e);
       if (e.cause != null) {
         // Example:
         // PgError.conn_ended: Unable to do postgres query on ended connection

package/src/replication/WalStreamReplicator.ts

@@ -2,6 +2,7 @@ import { replication, storage } from '@powersync/service-core';
 import { ConnectionManagerFactory } from './ConnectionManagerFactory.js';
 import { cleanUpReplicationSlot } from './replication-utils.js';
 import { WalStreamReplicationJob } from './WalStreamReplicationJob.js';
+import { PostgresModule } from '../module/PostgresModule.js';
 
 export interface WalStreamReplicatorOptions extends replication.AbstractReplicatorOptions {
   connectionFactory: ConnectionManagerFactory;
@@ -42,4 +43,8 @@ export class WalStreamReplicator extends replication.AbstractReplicator<WalStrea
     await super.stop();
     await this.connectionFactory.shutdown();
   }
+
+  async testConnection() {
+    return await PostgresModule.testConnection(this.connectionFactory.dbConnectionConfig);
+  }
 }

package/src/replication/replication-utils.ts

@@ -1,7 +1,7 @@
 import * as pgwire from '@powersync/service-jpgwire';
 
 import * as lib_postgres from '@powersync/lib-service-postgres';
-import { logger } from '@powersync/lib-services-framework';
+import { ErrorCode, logger, ServiceError } from '@powersync/lib-services-framework';
 import { PatternResult, storage } from '@powersync/service-core';
 import * as sync_rules from '@powersync/service-sync-rules';
 import * as service_types from '@powersync/service-types';
@@ -117,17 +117,22 @@ $$ LANGUAGE plpgsql;`
   });
   const row = pgwire.pgwireRows(rs)[0];
   if (row == null) {
-    throw new Error(
+    throw new ServiceError(
+      ErrorCode.PSYNC_S1141,
       `Publication '${publicationName}' does not exist. Run: \`CREATE PUBLICATION ${publicationName} FOR ALL TABLES\`, or read the documentation for details.`
     );
   }
   if (row.pubinsert == false || row.pubupdate == false || row.pubdelete == false || row.pubtruncate == false) {
-    throw new Error(
+    throw new ServiceError(
+      ErrorCode.PSYNC_S1142,
       `Publication '${publicationName}' does not publish all changes. Create a publication using \`WITH (publish = "insert, update, delete, truncate")\` (the default).`
     );
   }
   if (row.pubviaroot) {
-    throw new Error(`'${publicationName}' uses publish_via_partition_root, which is not supported.`);
+    throw new ServiceError(
+      ErrorCode.PSYNC_S1143,
+      `'${publicationName}' uses publish_via_partition_root, which is not supported.`
+    );
   }
 }
 

package/src/utils/migration_lib.ts

@@ -1,3 +1,4 @@
+import { ServiceAssertionError } from '@powersync/lib-services-framework';
 import * as pgwire from '@powersync/service-jpgwire';
 
 export type MigrationFunction = (db: pgwire.PgConnection) => Promise<void>;
@@ -14,7 +15,7 @@ export class Migrations {
 
   add(id: number, name: string, up: MigrationFunction) {
     if (this.migrations.length > 0 && this.migrations[this.migrations.length - 1].id >= id) {
-      throw new Error('Migration ids must be strictly incrementing');
+      throw new ServiceAssertionError('Migration ids must be strictly incrementing');
     }
     this.migrations.push({ id, up, name });
   }