@powersync/service-module-postgres 0.3.0 → 0.5.0

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

@@ -50,6 +50,7 @@ export class PgManager {
     // for the full 6 minutes.
     // This we are constantly using the connection, we don't need any
     // custom keepalives.
+
     (connection as any)._socket.setTimeout(SNAPSHOT_SOCKET_TIMEOUT);
 
     // Disable statement timeout for snapshot queries.

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,8 +1,16 @@
-import { container, errors, logger } from '@powersync/lib-services-framework';
+import * as lib_postgres from '@powersync/lib-service-postgres';
+import {
+  container,
+  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';
 import * as pg_utils from '../utils/pgwire_utils.js';
+
 import { PgManager } from './PgManager.js';
 import { getPgOutputRelation, getRelId } from './PgRelation.js';
 import { checkSourceConfiguration, getReplicationIdentityColumns } from './replication-utils.js';
@@ -63,7 +71,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 = pg_utils.retriedQuery(
+          const promise = lib_postgres.retriedQuery(
             this.connections.pool,
             `SELECT * FROM pg_logical_emit_message(false, 'powersync', 'ping')`
           );
@@ -131,7 +139,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);
 
@@ -292,7 +300,7 @@ export class WalStream {
       }
     }
 
-    throw new Error('Unreachable');
+    throw new ReplicationAssertionError('Unreachable');
   }
 
   async estimatedCount(db: pgwire.PgConnection, table: storage.SourceTable): Promise<string> {
@@ -413,7 +421,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)) {
@@ -439,7 +447,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,
@@ -482,6 +490,7 @@ WHERE  oid = $1::regclass`,
           await db.query('COMMIT');
         } catch (e) {
           await db.query('ROLLBACK');
+          // TODO: Wrap with custom error type
           throw e;
         }
       } finally {
@@ -499,7 +508,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;
   }

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,13 +1,11 @@
 import * as pgwire from '@powersync/service-jpgwire';
 
+import * as lib_postgres from '@powersync/lib-service-postgres';
+import { ErrorCode, logger, ServiceError } from '@powersync/lib-services-framework';
 import { PatternResult, storage } from '@powersync/service-core';
-import * as pgwire_utils from '../utils/pgwire_utils.js';
-import { ReplicationIdentity } from './PgRelation.js';
 import * as sync_rules from '@powersync/service-sync-rules';
 import * as service_types from '@powersync/service-types';
-import * as pg_utils from '../utils/pgwire_utils.js';
-import * as util from '../utils/pgwire_utils.js';
-import { logger } from '@powersync/lib-services-framework';
+import { ReplicationIdentity } from './PgRelation.js';
 
 export interface ReplicaIdentityResult {
   replicationColumns: storage.ColumnDescriptor[];
@@ -20,7 +18,7 @@ export async function getPrimaryKeyColumns(
   mode: 'primary' | 'replident'
 ): Promise<storage.ColumnDescriptor[]> {
   const indexFlag = mode == 'primary' ? `i.indisprimary` : `i.indisreplident`;
-  const attrRows = await pgwire_utils.retriedQuery(db, {
+  const attrRows = await lib_postgres.retriedQuery(db, {
     statement: `SELECT a.attname as name, a.atttypid as typeid, t.typname as type, a.attnum as attnum
                                     FROM pg_index i
                                     JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY (i.indkey)
@@ -41,7 +39,7 @@ export async function getPrimaryKeyColumns(
 }
 
 export async function getAllColumns(db: pgwire.PgClient, relationId: number): Promise<storage.ColumnDescriptor[]> {
-  const attrRows = await pgwire_utils.retriedQuery(db, {
+  const attrRows = await lib_postgres.retriedQuery(db, {
     statement: `SELECT a.attname as name, a.atttypid as typeid, t.typname as type, a.attnum as attnum
                                     FROM pg_attribute a
                                     JOIN pg_type t ON a.atttypid = t.oid
@@ -62,7 +60,7 @@ export async function getReplicationIdentityColumns(
   db: pgwire.PgClient,
   relationId: number
 ): Promise<ReplicaIdentityResult> {
-  const rows = await pgwire_utils.retriedQuery(db, {
+  const rows = await lib_postgres.retriedQuery(db, {
     statement: `SELECT CASE relreplident
         WHEN 'd' THEN 'default'
         WHEN 'n' THEN 'nothing'
@@ -95,7 +93,7 @@ WHERE oid = $1::oid LIMIT 1`,
 
 export async function checkSourceConfiguration(db: pgwire.PgClient, publicationName: string): Promise<void> {
   // Check basic config
-  await pgwire_utils.retriedQuery(
+  await lib_postgres.retriedQuery(
     db,
     `DO $$
 BEGIN
@@ -113,23 +111,28 @@ $$ LANGUAGE plpgsql;`
   );
 
   // Check that publication exists
-  const rs = await pgwire_utils.retriedQuery(db, {
+  const rs = await lib_postgres.retriedQuery(db, {
     statement: `SELECT * FROM pg_publication WHERE pubname = $1`,
     params: [{ type: 'varchar', value: publicationName }]
   });
   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.`
+    );
   }
 }
 
@@ -158,7 +161,7 @@ export async function getDebugTablesInfo(options: GetDebugTablesInfoOptions): Pr
     if (tablePattern.isWildcard) {
       patternResult.tables = [];
       const prefix = tablePattern.tablePrefix;
-      const results = await util.retriedQuery(db, {
+      const results = await lib_postgres.retriedQuery(db, {
         statement: `SELECT c.oid AS relid, c.relname AS table_name
         FROM pg_class c
         JOIN pg_namespace n ON n.oid = c.relnamespace
@@ -189,7 +192,7 @@ export async function getDebugTablesInfo(options: GetDebugTablesInfoOptions): Pr
         patternResult.tables.push(details);
       }
     } else {
-      const results = await util.retriedQuery(db, {
+      const results = await lib_postgres.retriedQuery(db, {
         statement: `SELECT c.oid AS relid, c.relname AS table_name
         FROM pg_class c
         JOIN pg_namespace n ON n.oid = c.relnamespace
@@ -284,14 +287,14 @@ export async function getDebugTableInfo(options: GetDebugTableInfoOptions): Prom
 
   let selectError = null;
   try {
-    await pg_utils.retriedQuery(db, `SELECT * FROM ${sourceTable.escapedIdentifier} LIMIT 1`);
+    await lib_postgres.retriedQuery(db, `SELECT * FROM ${sourceTable.escapedIdentifier} LIMIT 1`);
   } catch (e) {
     selectError = { level: 'fatal', message: e.message };
   }
 
   let replicateError = null;
 
-  const publications = await pg_utils.retriedQuery(db, {
+  const publications = await lib_postgres.retriedQuery(db, {
     statement: `SELECT tablename FROM pg_publication_tables WHERE pubname = $1 AND schemaname = $2 AND tablename = $3`,
     params: [
       { type: 'varchar', value: publicationName },

package/src/types/types.ts

@@ -1,56 +1,18 @@
+import * as lib_postgres from '@powersync/lib-service-postgres';
 import * as service_types from '@powersync/service-types';
 import * as t from 'ts-codec';
-import * as urijs from 'uri-js';
 
-export const POSTGRES_CONNECTION_TYPE = 'postgresql' as const;
-
-export interface NormalizedPostgresConnectionConfig {
-  id: string;
-  tag: string;
-
-  hostname: string;
-  port: number;
-  database: string;
-
-  username: string;
-  password: string;
-
-  sslmode: 'verify-full' | 'verify-ca' | 'disable';
-  cacert: string | undefined;
-
-  client_certificate: string | undefined;
-  client_private_key: string | undefined;
-}
+// Maintain backwards compatibility by exporting these
+export const validatePort = lib_postgres.validatePort;
+export const baseUri = lib_postgres.baseUri;
+export type NormalizedPostgresConnectionConfig = lib_postgres.NormalizedBasePostgresConnectionConfig;
+export const POSTGRES_CONNECTION_TYPE = lib_postgres.POSTGRES_CONNECTION_TYPE;
 
 export const PostgresConnectionConfig = service_types.configFile.DataSourceConfig.and(
+  lib_postgres.BasePostgresConnectionConfig
+).and(
   t.object({
-    type: t.literal(POSTGRES_CONNECTION_TYPE),
-    /** Unique identifier for the connection - optional when a single connection is present. */
-    id: t.string.optional(),
-    /** Tag used as reference in sync rules. Defaults to "default". Does not have to be unique. */
-    tag: t.string.optional(),
-    uri: t.string.optional(),
-    hostname: t.string.optional(),
-    port: service_types.configFile.portCodec.optional(),
-    username: t.string.optional(),
-    password: t.string.optional(),
-    database: t.string.optional(),
-
-    /** Defaults to verify-full */
-    sslmode: t.literal('verify-full').or(t.literal('verify-ca')).or(t.literal('disable')).optional(),
-    /** Required for verify-ca, optional for verify-full */
-    cacert: t.string.optional(),
-
-    client_certificate: t.string.optional(),
-    client_private_key: t.string.optional(),
-
-    /** Expose database credentials */
-    demo_database: t.boolean.optional(),
-
-    /**
-     * Prefix for the slot name. Defaults to "powersync_"
-     */
-    slot_name_prefix: t.string.optional()
+    // Add any replication connection specific config here in future
   })
 );
 
@@ -64,101 +26,19 @@ export type PostgresConnectionConfig = t.Decoded<typeof PostgresConnectionConfig
  */
 export type ResolvedConnectionConfig = PostgresConnectionConfig & NormalizedPostgresConnectionConfig;
 
-/**
- * Validate and normalize connection options.
- *
- * Returns destructured options.
- */
-export function normalizeConnectionConfig(options: PostgresConnectionConfig): NormalizedPostgresConnectionConfig {
-  let uri: urijs.URIComponents;
-  if (options.uri) {
-    uri = urijs.parse(options.uri);
-    if (uri.scheme != 'postgresql' && uri.scheme != 'postgres') {
-      `Invalid URI - protocol must be postgresql, got ${uri.scheme}`;
-    } else if (uri.scheme != 'postgresql') {
-      uri.scheme = 'postgresql';
-    }
-  } else {
-    uri = urijs.parse('postgresql:///');
-  }
-
-  const hostname = options.hostname ?? uri.host ?? '';
-  const port = validatePort(options.port ?? uri.port ?? 5432);
-
-  const database = options.database ?? uri.path?.substring(1) ?? '';
-
-  const [uri_username, uri_password] = (uri.userinfo ?? '').split(':');
-
-  const username = options.username ?? uri_username ?? '';
-  const password = options.password ?? uri_password ?? '';
-
-  const sslmode = options.sslmode ?? 'verify-full'; // Configuration not supported via URI
-  const cacert = options.cacert;
-
-  if (sslmode == 'verify-ca' && cacert == null) {
-    throw new Error('Explicit cacert is required for sslmode=verify-ca');
-  }
-
-  if (hostname == '') {
-    throw new Error(`hostname required`);
-  }
-
-  if (username == '') {
-    throw new Error(`username required`);
-  }
-
-  if (password == '') {
-    throw new Error(`password required`);
-  }
-
-  if (database == '') {
-    throw new Error(`database required`);
-  }
-
-  return {
-    id: options.id ?? 'default',
-    tag: options.tag ?? 'default',
-
-    hostname,
-    port,
-    database,
-
-    username,
-    password,
-    sslmode,
-    cacert,
-
-    client_certificate: options.client_certificate ?? undefined,
-    client_private_key: options.client_private_key ?? undefined
-  };
-}
-
 export function isPostgresConfig(
   config: service_types.configFile.DataSourceConfig
 ): config is PostgresConnectionConfig {
-  return config.type == POSTGRES_CONNECTION_TYPE;
-}
-
-/**
- * Check whether the port is in a "safe" range.
- *
- * We do not support connecting to "privileged" ports.
- */
-export function validatePort(port: string | number): number {
-  if (typeof port == 'string') {
-    port = parseInt(port);
-  }
-  if (port < 1024) {
-    throw new Error(`Port ${port} not supported`);
-  }
-  return port;
+  return config.type == lib_postgres.POSTGRES_CONNECTION_TYPE;
 }
 
 /**
- * Construct a postgres URI, without username, password or ssl options.
+ * Validate and normalize connection options.
  *
- * Only contains hostname, port, database.
+ * Returns destructured options.
  */
-export function baseUri(options: NormalizedPostgresConnectionConfig) {
-  return `postgresql://${options.hostname}:${options.port}/${options.database}`;
+export function normalizeConnectionConfig(options: PostgresConnectionConfig) {
+  return {
+    ...lib_postgres.normalizeConnectionConfig(options)
+  } satisfies NormalizedPostgresConnectionConfig;
 }

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 });
   }

package/src/utils/pgwire_utils.ts

@@ -1,9 +1,7 @@
 // Adapted from https://github.com/kagis/pgwire/blob/0dc927f9f8990a903f238737326e53ba1c8d094f/mod.js#L2218
 
 import * as pgwire from '@powersync/service-jpgwire';
-import { SqliteJsonValue, SqliteRow, toSyncRulesRow } from '@powersync/service-sync-rules';
-
-import { logger } from '@powersync/lib-services-framework';
+import { DatabaseInputRow, SqliteRow, toSyncRulesRow } from '@powersync/service-sync-rules';
 
 /**
  * pgwire message -> SQLite row.
@@ -12,7 +10,7 @@ import { logger } from '@powersync/lib-services-framework';
 export function constructAfterRecord(message: pgwire.PgoutputInsert | pgwire.PgoutputUpdate): SqliteRow {
   const rawData = (message as any).afterRaw;
 
-  const record = pgwire.decodeTuple(message.relation, rawData);
+  const record = decodeTuple(message.relation, rawData);
   return toSyncRulesRow(record);
 }
 
@@ -25,49 +23,24 @@ export function constructBeforeRecord(message: pgwire.PgoutputDelete | pgwire.Pg
   if (rawData == null) {
     return undefined;
   }
-  const record = pgwire.decodeTuple(message.relation, rawData);
+  const record = decodeTuple(message.relation, rawData);
   return toSyncRulesRow(record);
 }
 
-export function escapeIdentifier(identifier: string) {
-  return `"${identifier.replace(/"/g, '""').replace(/\./g, '"."')}"`;
-}
-
-export function autoParameter(arg: SqliteJsonValue | boolean): pgwire.StatementParam {
-  if (arg == null) {
-    return { type: 'varchar', value: null };
-  } else if (typeof arg == 'string') {
-    return { type: 'varchar', value: arg };
-  } else if (typeof arg == 'number') {
-    if (Number.isInteger(arg)) {
-      return { type: 'int8', value: arg };
-    } else {
-      return { type: 'float8', value: arg };
-    }
-  } else if (typeof arg == 'boolean') {
-    return { type: 'bool', value: arg };
-  } else if (typeof arg == 'bigint') {
-    return { type: 'int8', value: arg };
-  } else {
-    throw new Error(`Unsupported query parameter: ${typeof arg}`);
-  }
-}
-
-export async function retriedQuery(db: pgwire.PgClient, ...statements: pgwire.Statement[]): Promise<pgwire.PgResult>;
-export async function retriedQuery(db: pgwire.PgClient, query: string): Promise<pgwire.PgResult>;
-
 /**
- * Retry a simple query - up to 2 attempts total.
+ * We need a high level of control over how values are decoded, to make sure there is no loss
+ * of precision in the process.
  */
-export async function retriedQuery(db: pgwire.PgClient, ...args: any[]) {
-  for (let tries = 2; ; tries--) {
-    try {
-      return await db.query(...args);
-    } catch (e) {
-      if (tries == 1) {
-        throw e;
-      }
-      logger.warn('Query error, retrying', e);
+export function decodeTuple(relation: pgwire.PgoutputRelation, tupleRaw: Record<string, any>): DatabaseInputRow {
+  let result: Record<string, any> = {};
+  for (let columnName in tupleRaw) {
+    const rawval = tupleRaw[columnName];
+    const typeOid = (relation as any)._tupleDecoder._typeOids.get(columnName);
+    if (typeof rawval == 'string' && typeOid) {
+      result[columnName] = pgwire.PgType.decode(rawval, typeOid);
+    } else {
+      result[columnName] = rawval;
     }
   }
+  return result;
 }

package/test/src/__snapshots__/schema_changes.test.ts.snap

@@ -0,0 +1,5 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`schema changes - mongodb > add to publication (not in sync rules) 1`] = `0`;
+
+exports[`schema changes - postgres > add to publication (not in sync rules) 1`] = `16384`;

package/test/src/env.ts

@@ -2,7 +2,10 @@ import { utils } from '@powersync/lib-services-framework';
 
 export const env = utils.collectEnvironmentVariables({
   PG_TEST_URL: utils.type.string.default('postgres://postgres:postgres@localhost:5432/powersync_test'),
+  PG_STORAGE_TEST_URL: utils.type.string.default('postgres://postgres:postgres@localhost:5431/powersync_storage_test'),
   MONGO_TEST_URL: utils.type.string.default('mongodb://localhost:27017/powersync_test'),
   CI: utils.type.boolean.default('false'),
-  SLOW_TESTS: utils.type.boolean.default('false')
+  SLOW_TESTS: utils.type.boolean.default('false'),
+  TEST_MONGO_STORAGE: utils.type.boolean.default('true'),
+  TEST_POSTGRES_STORAGE: utils.type.boolean.default('true')
 });

package/test/src/large_batch.test.ts

@@ -3,10 +3,14 @@ import * as timers from 'timers/promises';
 import { describe, expect, test } from 'vitest';
 import { populateData } from '../../dist/utils/populate_test_data.js';
 import { env } from './env.js';
-import { INITIALIZED_MONGO_STORAGE_FACTORY, TEST_CONNECTION_OPTIONS } from './util.js';
+import {
+  INITIALIZED_MONGO_STORAGE_FACTORY,
+  INITIALIZED_POSTGRES_STORAGE_FACTORY,
+  TEST_CONNECTION_OPTIONS
+} from './util.js';
 import { WalStreamTestContext } from './wal_stream_utils.js';
 
-describe('batch replication tests - mongodb', { timeout: 120_000 }, function () {
+describe.skipIf(!env.TEST_MONGO_STORAGE)('batch replication tests - mongodb', { timeout: 120_000 }, function () {
   // These are slow but consistent tests.
   // Not run on every test run, but we do run on CI, or when manually debugging issues.
   if (env.CI || env.SLOW_TESTS) {
@@ -17,6 +21,17 @@ describe('batch replication tests - mongodb', { timeout: 120_000 }, function ()
   }
 });
 
+describe.skipIf(!env.TEST_POSTGRES_STORAGE)('batch replication tests - postgres', { timeout: 240_000 }, function () {
+  // These are slow but consistent tests.
+  // Not run on every test run, but we do run on CI, or when manually debugging issues.
+  if (env.CI || env.SLOW_TESTS) {
+    defineBatchTests(INITIALIZED_POSTGRES_STORAGE_FACTORY);
+  } else {
+    // Need something in this file.
+    test('no-op', () => {});
+  }
+});
+
 const BASIC_SYNC_RULES = `bucket_definitions:
   global:
     data:

package/test/src/schema_changes.test.ts

@@ -3,13 +3,18 @@ import * as timers from 'timers/promises';
 import { describe, expect, test } from 'vitest';
 
 import { storage } from '@powersync/service-core';
-import { INITIALIZED_MONGO_STORAGE_FACTORY } from './util.js';
+import { env } from './env.js';
+import { INITIALIZED_MONGO_STORAGE_FACTORY, INITIALIZED_POSTGRES_STORAGE_FACTORY } from './util.js';
 import { WalStreamTestContext } from './wal_stream_utils.js';
 
-describe('schema changes', { timeout: 20_000 }, function () {
+describe.skipIf(!env.TEST_MONGO_STORAGE)('schema changes - mongodb', { timeout: 20_000 }, function () {
   defineTests(INITIALIZED_MONGO_STORAGE_FACTORY);
 });
 
+describe.skipIf(!env.TEST_POSTGRES_STORAGE)('schema changes - postgres', { timeout: 20_000 }, function () {
+  defineTests(INITIALIZED_POSTGRES_STORAGE_FACTORY);
+});
+
 const BASIC_SYNC_RULES = `
 bucket_definitions:
   global:
@@ -432,7 +437,7 @@ function defineTests(factory: storage.TestStorageFactory) {
     expect(data).toMatchObject([]);
 
     const metrics = await storage.factory.getStorageMetrics();
-    expect(metrics.replication_size_bytes).toEqual(0);
+    expect(metrics.replication_size_bytes).toMatchSnapshot();
   });
 
   test('replica identity nothing', async () => {