import { baseUri, NormalizedBasePostgresConnectionConfig } from '@powersync/lib-service-postgres'; import { api, ConnectionTestResult, modules, replication, system } from '@powersync/service-core'; import { PostgresRouteAPIAdapter } from '../api/PostgresRouteAPIAdapter.js'; import { ConnectionManagerFactory } from '../replication/ConnectionManagerFactory.js'; import { PgManager } from '../replication/PgManager.js'; import { PostgresErrorRateLimiter } from '../replication/PostgresErrorRateLimiter.js'; import { checkSourceConfiguration, cleanUpReplicationSlot } from '../replication/replication-utils.js'; 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 { getApplicationName } from '../utils/application-name.js'; export class PostgresModule extends replication.ReplicationModule { constructor() { super({ name: 'Postgres', type: types.POSTGRES_CONNECTION_TYPE, configSchema: types.PostgresConnectionConfig }); } protected createRouteAPIAdapter(): api.RouteAPI { return PostgresRouteAPIAdapter.withConfig(this.resolveConfig(this.decodedConfig!)); } protected createReplicator(context: system.ServiceContext): replication.AbstractReplicator { const normalisedConfig = this.resolveConfig(this.decodedConfig!); const connectionFactory = new ConnectionManagerFactory(normalisedConfig); return new WalStreamReplicator({ id: this.getDefaultId(normalisedConfig.database), configuration: context.configuration, syncConfigEngine: context.syncConfigEngine, storageEngine: context.storageEngine, metricsEngine: context.metricsEngine, connectionFactory: connectionFactory, rateLimiter: new PostgresErrorRateLimiter(), heartbeatIntervalSeconds: normalisedConfig.heartbeat_interval_seconds }); } /** * Combines base config with normalized connection settings */ private resolveConfig(config: types.PostgresConnectionConfig): types.ResolvedConnectionConfig { return { ...config, ...types.normalizeConnectionConfig(config) }; } async teardown(options: modules.TearDownOptions): Promise { const normalisedConfig = this.resolveConfig(this.decodedConfig!); const connectionManager = new PgManager(normalisedConfig, { idleTimeout: 30_000, maxSize: 1, applicationName: getApplicationName() }); try { const replicationStreams = options.replicationStreams ?? options.syncRules; if (replicationStreams) { // TODO: In the future, once we have more replication types, we will need to check if these replication streams are for Postgres for (let replicationStream of replicationStreams) { try { await cleanUpReplicationSlot(replicationStream.replicationStreamName, connectionManager.pool); } catch (e) { // Not really much we can do here for failures, most likely the database is no longer accessible this.logger.warn( `Failed to fully clean up Postgres replication slot: ${replicationStream.replicationStreamName}`, e ); } } } } finally { await connectionManager.end(); } } async testConnection(config: PostgresConnectionConfig): Promise { this.decodeConfig(config); const normalizedConfig = this.resolveConfig(this.decodedConfig!); return await this.testConnection(normalizedConfig); } static async testConnection(normalizedConfig: NormalizedBasePostgresConnectionConfig): Promise { // FIXME: This is not a complete implementation yet. const connectionManager = new PgManager(normalizedConfig, { idleTimeout: 30_000, maxSize: 1, applicationName: getApplicationName() }); const connection = await connectionManager.snapshotConnection(); try { await checkSourceConfiguration(connection, PUBLICATION_NAME); } finally { await connectionManager.end(); } return { connectionDescription: baseUri(normalizedConfig) }; } }