@powersync/lib-service-postgres 0.0.0-dev-20250117095455 → 0.0.0-dev-20250227082606

package/src/db/connection/ConnectionSlot.ts

@@ -1,7 +1,7 @@
 import * as framework from '@powersync/lib-services-framework';
 import * as pgwire from '@powersync/service-jpgwire';
 
-export interface NotificationListener extends framework.DisposableListener {
+export interface NotificationListener {
   notification?: (payload: pgwire.PgNotification) => void;
 }
 
@@ -23,7 +23,7 @@ export type ConnectionSlotOptions = {
 
 export const MAX_CONNECTION_ATTEMPTS = 5;
 
-export class ConnectionSlot extends framework.DisposableObserver<ConnectionSlotListener> {
+export class ConnectionSlot extends framework.BaseObserver<ConnectionSlotListener> {
   isAvailable: boolean;
   isPoking: boolean;
 
@@ -50,9 +50,12 @@ export class ConnectionSlot extends framework.DisposableObserver<ConnectionSlotL
     const connection = await this.connectingPromise;
     this.connectingPromise = null;
     await this.iterateAsyncListeners(async (l) => l.connectionCreated?.(connection));
-    if (this.hasNotificationListener()) {
-      await this.configureConnectionNotifications(connection);
-    }
+
+    /**
+     * Configure the Postgres connection to listen to notifications.
+     * Subscribing to notifications, even without a registered listener, should not add much overhead.
+     */
+    await this.configureConnectionNotifications(connection);
     return connection;
   }
 
@@ -60,15 +63,10 @@ export class ConnectionSlot extends framework.DisposableObserver<ConnectionSlotL
     this.closed = true;
     const connection = this.connection ?? (await this.connectingPromise);
     await connection?.end();
-    return super[Symbol.dispose]();
+    super.clearListeners();
   }
 
   protected async configureConnectionNotifications(connection: pgwire.PgConnection) {
-    if (connection.onnotification == this.handleNotification || this.closed == true) {
-      // Already configured
-      return;
-    }
-
     connection.onnotification = this.handleNotification;
 
     for (const channelName of this.options.notificationChannels ?? []) {
@@ -78,19 +76,6 @@ export class ConnectionSlot extends framework.DisposableObserver<ConnectionSlotL
     }
   }
 
-  registerListener(listener: Partial<ConnectionSlotListener>): () => void {
-    const dispose = super.registerListener(listener);
-    if (this.connection && this.hasNotificationListener()) {
-      this.configureConnectionNotifications(this.connection);
-    }
-    return () => {
-      dispose();
-      if (this.connection && !this.hasNotificationListener()) {
-        this.connection.onnotification = () => {};
-      }
-    };
-  }
-
   protected handleNotification = (payload: pgwire.PgNotification) => {
     if (!this.options.notificationChannels?.includes(payload.channel)) {
       return;

package/src/db/connection/DatabaseClient.ts

@@ -32,7 +32,8 @@ export const TRANSACTION_CONNECTION_COUNT = 5;
 export class DatabaseClient extends AbstractPostgresConnection<DatabaseClientListener> {
   closed: boolean;
 
-  protected pool: pgwire.PgClient;
+  pool: pgwire.PgClient;
+
   protected connections: ConnectionSlot[];
 
   protected initialized: Promise<void>;
@@ -41,9 +42,13 @@ export class DatabaseClient extends AbstractPostgresConnection<DatabaseClientLis
   constructor(protected options: DatabaseClientOptions) {
     super();
     this.closed = false;
-    this.pool = pgwire.connectPgWirePool(options.config);
-    this.connections = Array.from({ length: TRANSACTION_CONNECTION_COUNT }, () => {
-      const slot = new ConnectionSlot({ config: options.config, notificationChannels: options.notificationChannels });
+    this.pool = pgwire.connectPgWirePool(options.config, {
+      maxSize: options.config.max_pool_size
+    });
+    this.connections = Array.from({ length: TRANSACTION_CONNECTION_COUNT }, (v, index) => {
+      // Only listen to notifications on a single (the first) connection
+      const notificationChannels = index == 0 ? options.notificationChannels : [];
+      const slot = new ConnectionSlot({ config: options.config, notificationChannels });
       slot.registerListener({
         connectionAvailable: () => this.processConnectionQueue(),
         connectionError: (ex) => this.handleConnectionError(ex),

package/src/types/types.ts

@@ -1,10 +1,12 @@
-import { makeHostnameLookupFunction } from '@powersync/lib-services-framework';
+import { ErrorCode, makeHostnameLookupFunction, ServiceError } from '@powersync/lib-services-framework';
 import type * as jpgwire from '@powersync/service-jpgwire';
 import * as service_types from '@powersync/service-types';
 import * as t from 'ts-codec';
 import * as urijs from 'uri-js';
 
-export interface NormalizedBasePostgresConnectionConfig extends jpgwire.NormalizedConnectionConfig {}
+export interface NormalizedBasePostgresConnectionConfig extends jpgwire.NormalizedConnectionConfig {
+  max_pool_size: number;
+}
 
 export const POSTGRES_CONNECTION_TYPE = 'postgresql' as const;
 
@@ -42,7 +44,9 @@ export const BasePostgresConnectionConfig = t.object({
   /**
    * Prefix for the slot name. Defaults to "powersync_"
    */
-  slot_name_prefix: t.string.optional()
+  slot_name_prefix: t.string.optional(),
+
+  max_pool_size: t.number.optional()
 });
 
 export type BasePostgresConnectionConfig = t.Encoded<typeof BasePostgresConnectionConfig>;
@@ -58,7 +62,10 @@ export function normalizeConnectionConfig(options: BasePostgresConnectionConfigD
   if (options.uri) {
     uri = urijs.parse(options.uri);
     if (uri.scheme != 'postgresql' && uri.scheme != 'postgres') {
-      `Invalid URI - protocol must be postgresql, got ${uri.scheme}`;
+      throw new ServiceError(
+        ErrorCode.PSYNC_S1109,
+        `Invalid URI - protocol must be postgresql, got ${JSON.stringify(uri.scheme)}`
+      );
     } else if (uri.scheme != 'postgresql') {
       uri.scheme = 'postgresql';
     }
@@ -80,23 +87,26 @@ export function normalizeConnectionConfig(options: BasePostgresConnectionConfigD
   const cacert = options.cacert;
 
   if (sslmode == 'verify-ca' && cacert == null) {
-    throw new Error('Explicit cacert is required for sslmode=verify-ca');
+    throw new ServiceError(
+      ErrorCode.PSYNC_S1104,
+      'Postgres connection: Explicit cacert is required for `sslmode: verify-ca`'
+    );
   }
 
   if (hostname == '') {
-    throw new Error(`hostname required`);
+    throw new ServiceError(ErrorCode.PSYNC_S1106, `Postgres connection: hostname required`);
   }
 
   if (username == '') {
-    throw new Error(`username required`);
+    throw new ServiceError(ErrorCode.PSYNC_S1107, `Postgres connection: username required`);
   }
 
   if (password == '') {
-    throw new Error(`password required`);
+    throw new ServiceError(ErrorCode.PSYNC_S1108, `Postgres connection: password required`);
   }
 
   if (database == '') {
-    throw new Error(`database required`);
+    throw new ServiceError(ErrorCode.PSYNC_S1105, `Postgres connection: database required`);
   }
 
   const lookupOptions = { reject_ip_ranges: options.reject_ip_ranges ?? [] };
@@ -119,7 +129,9 @@ export function normalizeConnectionConfig(options: BasePostgresConnectionConfigD
     lookup,
 
     client_certificate: options.client_certificate ?? undefined,
-    client_private_key: options.client_private_key ?? undefined
+    client_private_key: options.client_private_key ?? undefined,
+
+    max_pool_size: options.max_pool_size ?? 8
   } satisfies NormalizedBasePostgresConnectionConfig;
 }
 
@@ -132,8 +144,8 @@ export function validatePort(port: string | number): number {
   if (typeof port == 'string') {
     port = parseInt(port);
   }
-  if (port < 1024) {
-    throw new Error(`Port ${port} not supported`);
+  if (port < 1024 || port > 65535) {
+    throw new ServiceError(ErrorCode.PSYNC_S1110, `Port ${port} not supported`);
   }
   return port;
 }

package/src/utils/identifier-utils.ts

@@ -0,0 +1,38 @@
+import * as pgwire from '@powersync/service-jpgwire';
+import { retriedQuery } from './pgwire_utils.js';
+
+export interface DecodedPostgresIdentifier {
+  server_id: string;
+  database_name: string;
+}
+
+export const decodePostgresSystemIdentifier = (identifier: string): DecodedPostgresIdentifier => {
+  const [server_id, database_name] = identifier.split('.');
+  return { server_id, database_name };
+};
+
+export const encodePostgresSystemIdentifier = (decoded: DecodedPostgresIdentifier): string => {
+  return `${decoded.server_id}.${decoded.database_name}`;
+};
+
+export const queryPostgresSystemIdentifier = async (
+  connection: pgwire.PgClient
+): Promise<DecodedPostgresIdentifier> => {
+  const result = pgwire.pgwireRows(
+    await retriedQuery(
+      connection,
+      /* sql */ `
+        SELECT
+          current_database() AS database_name,
+          system_identifier
+        FROM
+          pg_control_system();
+      `
+    )
+  ) as Array<{ database_name: string; system_identifier: bigint }>;
+
+  return {
+    database_name: result[0].database_name,
+    server_id: result[0].system_identifier.toString()
+  };
+};

package/src/utils/pgwire_utils.ts

@@ -2,7 +2,7 @@
 
 import * as pgwire from '@powersync/service-jpgwire';
 
-import { logger } from '@powersync/lib-services-framework';
+import { logger, ServiceAssertionError } from '@powersync/lib-services-framework';
 
 export function escapeIdentifier(identifier: string) {
   return `"${identifier.replace(/"/g, '""').replace(/\./g, '"."')}"`;
@@ -24,7 +24,7 @@ export function autoParameter(arg: any): pgwire.StatementParam {
   } else if (typeof arg == 'bigint') {
     return { type: 'int8', value: arg };
   } else {
-    throw new Error(`Unsupported query parameter: ${typeof arg}`);
+    throw new ServiceAssertionError(`Unsupported query parameter: ${typeof arg}`);
   }
 }
 

package/src/utils/utils-index.ts

@@ -1 +1,2 @@
+export * from './identifier-utils.js';
 export * from './pgwire_utils.js';

package/tsconfig.json

@@ -8,5 +8,5 @@
     "sourceMap": true
   },
   "include": ["src"],
-  "references": [{ "path": "../../packages/jpgwire" }, { "path": "../lib-services" }]
+  "references": [{ "path": "../lib-services" }, { "path": "../../packages/jpgwire" }]
 }