pg-aequor 0.1.0

package/LICENSE

@@ -0,0 +1,17 @@
+ISC License
+
+Copyright (c) 2026 dimaq12
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+

package/README.md

@@ -0,0 +1,81 @@
+# pg-aequor
+
+If you use standard `pg` in AWS Lambda, you are either a madman or you haven't yet seen your database die under a pile of zombie connections. This library is a wrapper that forces PostgreSQL and Serverless to coexist in peace.
+
+---
+
+## Why isn't this just another wrapper?
+
+In standard environments, connections live long. In Lambda, they "freeze" in suspended instances. We solve this via **Signed Leases**:
+
+1.  **Signed Leases**: Each connection signs itself in `application_name` (expiration + HMAC).
+2.  **Distributed Reaper**: A background "Reaper" scans the database and kills connections whose lease has expired.
+3.  **Advisory Locks**: Coordination is handled via Postgres Advisory Locks, so instances don't fight each other to clean up the mess.
+
+---
+
+## Technical Rules (Read this so it doesn't hurt)
+
+*   **Disposable Idle**: If a connection is idle longer than the lease TTL, it is considered a corpse. Another instance will kill it. This is a feature, not a bug.
+*   **Crash Safety**: We swallow socket errors in `pg.Client` handlers. No more `Runtime.ExitError` crashing your entire Lambda.
+*   **Single Connection Architecture**: The Reaper runs on the *active* connection using Advisory Locks. It adds minimal latency to the "leader" request but prevents connection storms (Reaper-DOS) during massive scale-ups.
+
+---
+
+## Configuration
+
+### Required Parameters (Lease/Reaper)
+
+| Parameter | Type | Description |
+| :--- | :--- | :--- |
+| `secret` | `string` | **Critical.** Shared secret for HMAC signing. Do NOT use your DB password. Must be at least 16 bytes. |
+| `leaseMode` | `string` | `'required'` (throws without secret) or `'optional'`. Default: `'required'`. |
+| `leaseTtlMs` | `number` | Lease Time-To-Live in milliseconds. Default: `90000` (90s). |
+
+### Retry Strategy
+
+We use **Decorrelated Jitter** and **SQLSTATE** filtering. Retries trigger only on transient errors (network, DB restart, connection limits).
+
+---
+
+## Observability (Hooks)
+
+Do not put heavy logic in hooks. Use them for metrics.
+
+```javascript
+const { ServerlessClient } = require('pg-aequor')
+
+const client = new ServerlessClient({
+  host: process.env.DB_HOST,
+  user: process.env.DB_USER,
+  password: process.env.DB_PASSWORD,
+  database: process.env.DB_NAME,
+  
+  // Coordination Secret (Distinct from DB password)
+  secret: process.env.COORD_SECRET,
+
+  hooks: {
+    onQueryRetry: ({ retries, err }) => {
+      console.warn(`Retry #${retries} due to ${err.code}`)
+    },
+    onClientDead: ({ source, meta }) => {
+      // Perfect for CloudWatch EMF or X-Ray
+      logToEMF('ClientDeath', 1, { sqlstate: meta?.sqlstate })
+    }
+  }
+})
+
+await client.connect()
+const res = await client.query('SELECT NOW()')
+await client.clean() // or await client.end()
+```
+
+---
+
+## Installation
+
+```bash
+npm install pg-aequor
+```
+
+> **Attention:** This library requires `pg` as a peer dependency. Tested on versions `^8.11.0`.

package/index.d.ts

@@ -0,0 +1,200 @@
+import { Client, ClientConfig, QueryResult, QueryResultRow } from 'pg';
+
+export interface ServerlessClientHooks {
+  /**
+   * Called when a new database connection is successfully established.
+   */
+  onConnect?: (payload: { gen: number }) => void;
+
+  /**
+   * Called when a connection attempt fails and is about to be retried.
+   */
+  onReconnect?: (payload: { gen: number; retries: number; delay: number; err: Error }) => void;
+
+  /**
+   * Called when a query fails with a retryable error and is about to be retried.
+   */
+  onQueryRetry?: (payload: { retries: number; delay: number; err: Error }) => void;
+
+  /**
+   * Called when a heartbeat (lease renewal) succeeds.
+   */
+  onHeartbeat?: (payload: { gen: number }) => void;
+
+  /**
+   * Called when a heartbeat fails (either transiently or permanently).
+   */
+  onHeartbeatFail?: (payload: { gen: number; err: Error }) => void;
+
+  /**
+   * Called when the underlying pg.Client emits an 'error' event or ends unexpectedly.
+   * This is a critical signal that the connection is dead.
+   */
+  onClientDead?: (payload: { source: 'error' | 'end'; err?: Error; meta?: { sqlstate?: string; [key: string]: any } }) => void;
+
+  /**
+   * Called immediately before a user query is executed. Useful for tracing start time.
+   */
+  onQueryStart?: (payload: { args: any[]; startedAt: number }) => void;
+
+  /**
+   * Called immediately after a user query successfully completes.
+   */
+  onQueryEnd?: (payload: { args: any[]; res: QueryResult<any>; duration: number }) => void;
+
+  /**
+   * Called when a user query fails (before retry logic kicks in).
+   */
+  onQueryError?: (payload: { args: any[]; err: Error; duration: number }) => void;
+}
+
+export interface ServerlessClientConfig extends ClientConfig {
+  /**
+   * Shared secret for signing leases. Required if leaseMode is 'required'.
+   * Conceptually distinct from DB password. Must be at least 16 bytes.
+   */
+  secret?: string;
+
+  /**
+   * Logical name of the service using this client. Used for advisory lock namespace.
+   * Defaults to AWS_LAMBDA_FUNCTION_NAME or 'sls_pg'.
+   */
+  serviceName?: string;
+
+  /**
+   * Coordination mode.
+   * - 'required': throws if secret is missing (default).
+   * - 'optional': disables lease/reaper if secret is missing.
+   */
+  leaseMode?: 'required' | 'optional';
+
+  /**
+   * Enable/disable the background connection reaper. Default: true.
+   */
+  reaper?: boolean;
+
+  /**
+   * Probability (0.0 - 1.0) of running the reaper on connect.
+   * Alias for legacy 'connUtilization'. Default: 0.1.
+   */
+  reaperRunProbability?: number;
+
+  /**
+   * Minimum time (ms) between reaper runs on this container. Default: 120000 (2m).
+   */
+  reaperCooldownMs?: number;
+
+  /**
+   * How to handle reaper internal errors.
+   * - 'swallow': log and ignore (default).
+   * - 'throw': throw exception to the caller.
+   */
+  reaperErrorMode?: 'swallow' | 'throw';
+
+  /**
+   * Minimum idle time (seconds) before a connection is considered a zombie candidate.
+   * Default: 180 (3m).
+   */
+  minConnectionIdleTimeSec?: number;
+
+  /**
+   * Maximum number of zombie connections to kill in one reaper pass. Default: 1.
+   */
+  maxIdleConnectionsToKill?: number;
+
+  /**
+   * Lease time-to-live in milliseconds. Default: 90000 (90s).
+   */
+  leaseTtlMs?: number;
+
+  /**
+   * Time remaining (ms) where we soft-check lease renewal. Default: 30000.
+   */
+  heartbeatSoftRemainingMs?: number;
+
+  /**
+   * Time remaining (ms) where we force-wait for lease renewal. Default: 5000.
+   */
+  heartbeatHardWaitRemainingMs?: number;
+
+  /**
+   * Time (ms) to wait for set_config heartbeat query before timing out. Default: 2000.
+   */
+  heartbeatTimeoutMs?: number;
+
+  /**
+   * Action on heartbeat failure.
+   * - 'reconnect': mark client dead and reconnect (safest for serverless).
+   * - 'swallow': log and ignore.
+   * - 'throw': throw error.
+   * Default: 'reconnect'.
+   */
+  heartbeatErrorMode?: 'reconnect' | 'swallow' | 'throw';
+
+  /**
+   * Max time (ms) to spend retrying a connect operation. Default: 15000.
+   */
+  maxConnectRetryTimeMs?: number;
+
+  /**
+   * Max time (ms) to spend retrying a query operation. Default: 15000.
+   */
+  maxQueryRetryTimeMs?: number;
+
+  /**
+   * Default query_timeout (ms) passed to pg if not specified in individual query.
+   */
+  defaultQueryTimeoutMs?: number;
+
+  /**
+   * Observability hooks.
+   */
+  hooks?: ServerlessClientHooks;
+
+  /**
+   * Debug logging (console.log). Default: false.
+   */
+  debug?: boolean;
+
+  /**
+   * Underlying pg driver instance (e.g. for X-Ray capture).
+   */
+  library?: any;
+
+  // Legacy aliases
+  connUtilization?: number;
+  applicationName?: string;
+}
+
+export class ServerlessClient {
+  constructor(config: ServerlessClientConfig);
+
+  /**
+   * Establishes a connection (if not already connected) and acquires a lease.
+   */
+  connect(): Promise<void>;
+
+  /**
+   * Executes a query with automatic retry and lease management.
+   */
+  query<R extends QueryResultRow = any, I extends any[] = any[]>(
+    queryTextOrConfig: string | import('pg').QueryConfig<I>,
+    values?: I
+  ): Promise<QueryResult<R>>;
+
+  /**
+   * Gracefully closes the connection.
+   */
+  clean(): Promise<void>;
+
+  /**
+   * Alias for clean().
+   */
+  end(): Promise<void>;
+  
+  /**
+   * Returns the underlying pg.Client instance (if connected).
+   * Use with caution.
+   */
+  getClient(): Client | null;
+}

package/index.js

@@ -0,0 +1,7 @@
+const ServerlessClient = require('./lib/client')
+
+// Canonical export: match serverless-postgres API.
+module.exports = {
+  ServerlessClient,
+}
+

package/lib/client.js

@@ -0,0 +1,413 @@
+const RetryStrategy = require('./retry')
+const LeaseManager = require('./lease')
+const Reaper = require('./reaper')
+const crypto = require('crypto')
+
+class ServerlessClient {
+  constructor(config = {}) {
+    this._config = config
+    this._library = config.library || require('pg')
+    this._client = null
+    this._isDead = false // Flag to force recreation
+    this._generation = 0
+    this._connectPromise = null
+    
+    // Retry Strategy
+    this._retryStrategy = {
+      retries: config.retries ?? 3,
+      minBackoff: config.minBackoff ?? 100, // ms
+      maxBackoff: config.maxBackoff ?? 2000 // ms
+    }
+
+    // Lease/Reaper mode:
+    // - required: secret must be provided (safe distributed coordination)
+    // - optional: if secret missing, disable lease/reaper/heartbeat but client still works
+    this._leaseMode = config.leaseMode || 'required' // 'required' | 'optional'
+
+    // Reaper config (can be disabled if lease is disabled)
+    this._reaperEnabled = config.reaper !== false
+    this._strategy = {
+      // Probability of running a reaper pass on connect (0..1). Alias for backwards compatibility.
+      reaperRunProbability: config.reaperRunProbability ?? config.connUtilization ?? 0.1,
+      // Default should be minutes, not seconds, otherwise you create your own outages.
+      minConnIdleTimeSec: config.minConnectionIdleTimeSec || 180, // Default 3m
+      maxIdleConnectionsToKill: config.maxIdleConnectionsToKill || 10,
+      reaperErrorMode: config.reaperErrorMode || 'swallow', // 'swallow' | 'throw'
+    }
+    this._reaperCooldownMs = config.reaperCooldownMs ?? 30000
+    // Jittered Cooldown Base: Add random offset to avoid synchronized reapers
+    this._reaperBaseInterval = this._reaperCooldownMs + Math.random() * (this._reaperCooldownMs / 3)
+    this._reaperCurrentInterval = this._reaperBaseInterval
+    this._reaperNextRunAt = 0
+
+    // Setup Lease Manager
+    const serviceName = config.serviceName || process.env.AWS_LAMBDA_FUNCTION_NAME || 'sls_pg'
+    // 48-bit random instance id => exactly 8 base64url chars (no padding). Good entropy, tight budget.
+    const instanceId = crypto.randomBytes(6).toString('base64url')
+    const secret = config.secret // explicit coordination secret (not db password)
+    this._baseApplicationName =
+      (typeof config.application_name === 'string' && config.application_name) ||
+      (typeof config.applicationName === 'string' && config.applicationName) ||
+      serviceName
+
+    if (!secret) {
+      if (this._leaseMode === 'required') {
+        throw new Error('Missing config.secret (required for lease/reaper). Set leaseMode=\"optional\" to disable lease/reaper/heartbeat.')
+      }
+      this._leaseManager = null
+      this._reaperEnabled = false
+    } else {
+      this._leaseManager = new LeaseManager(serviceName, instanceId, secret)
+    }
+    
+    // Heartbeat state
+    this._leaseExp = 0
+    this._heartbeatPromise = null
+    this._leaseTtlMs = config.leaseTtlMs ?? 90000
+    this._heartbeatSoftRemainingMs = config.heartbeatSoftRemainingMs ?? 30000
+    this._heartbeatHardWaitRemainingMs = config.heartbeatHardWaitRemainingMs ?? 5000
+    this._heartbeatErrorMode = config.heartbeatErrorMode || 'reconnect' // 'swallow' | 'reconnect' | 'throw'
+    this._heartbeatTimeoutMs = config.heartbeatTimeoutMs ?? 2000
+    this._defaultQueryTimeoutMs = config.defaultQueryTimeoutMs ?? 0
+
+    // Logging
+    this._logger = config.debug ? console.log : () => {}
+    this._hooks = config.hooks || {}
+
+    // Backoff state (decorrelated jitter needs previous delay)
+    this._connectPrevDelay = 0
+    this._queryPrevDelay = 0
+    this._maxConnectRetryTimeMs = config.maxConnectRetryTimeMs ?? 15000
+    this._maxQueryRetryTimeMs = config.maxQueryRetryTimeMs ?? 15000
+  }
+
+  _safeHook(name, payload) {
+    const fn = this._hooks && this._hooks[name]
+    if (typeof fn !== 'function') return
+    try { fn(payload) } catch (_) { /* never throw from hooks */ }
+  }
+
+  async connect() {
+    if (this._client && !this._isDead) return
+    if (this._connectPromise) return this._connectPromise
+    const gen = ++this._generation
+    this._connectPromise = (async () => {
+      try {
+        await this._connectWithRetry(gen)
+      } finally {
+        this._connectPromise = null
+      }
+    })()
+    return this._connectPromise
+  }
+
+  async _connectWithRetry(gen) {
+    const startedAt = Date.now()
+    let retries = 0
+    while (true) {
+      try {
+        await this._connect(gen)
+        this._connectPrevDelay = 0
+        this._safeHook('onConnect', { gen })
+        return // Success
+      } catch (err) {
+        if (this._maxConnectRetryTimeMs > 0 && (Date.now() - startedAt) > this._maxConnectRetryTimeMs) {
+          throw err
+        }
+        if (!RetryStrategy.isRetryable(err) || retries >= this._retryStrategy.retries) {
+          throw err
+        }
+        retries++
+        const delay = RetryStrategy.getBackoff(
+          this._retryStrategy.minBackoff,
+          this._retryStrategy.maxBackoff,
+          this._connectPrevDelay
+        )
+        this._connectPrevDelay = delay
+        this._safeHook('onReconnect', { gen, retries, delay, err })
+        this._logger(`Connect Retry ${retries}/${this._retryStrategy.retries} after ${delay}ms: ${err.message}`)
+        await new Promise(res => setTimeout(res, delay))
+      }
+    }
+  }
+
+  async _connect(gen) {
+    // Internal cleanup before creating a new client should NOT invalidate this generation.
+    await this._disposeClient('reconnect', { bumpGeneration: false })
+
+    // Generate initial lease
+    let appName = String(this._baseApplicationName || 'app').slice(0, 63)
+    if (this._leaseManager) {
+      this._leaseExp = Date.now() + this._leaseTtlMs
+      appName = this._leaseManager.generateAppName(this._leaseExp)
+    } else {
+      this._leaseExp = 0
+    }
+    
+    const clientConfig = this._buildPgClientConfig({ application_name: appName })
+
+    const client = new this._library.Client(clientConfig)
+    
+    // Crash Safety: Swallow errors to prevent Runtime.ExitError
+    client.on('error', (err) => this._markDeadAndDispose(client, err, 'error'))
+    // If connection ends, the client is not reusable.
+    client.on('end', () => this._markDeadAndDispose(client, null, 'end'))
+
+    await client.connect()
+
+    // Generation guard: do not resurrect if a newer generation started while we were connecting.
+    if (this._generation !== gen) {
+      try { await client.end() } catch (_) {}
+      return
+    }
+
+    this._client = client
+    this._isDead = false
+
+    // Run Reaper if enabled (async, best effort)
+    if (this._reaperEnabled) {
+      this._reap().catch(err => this._logger('Reap failed:', err.message))
+    }
+  }
+
+  // Best-effort connection cleanup
+  async _reap() {
+    // 1. Check Lease Manager
+    if (!this._leaseManager) return
+
+    // 2. Jittered Cooldown + Backoff
+    const now = Date.now()
+    if (now < this._reaperNextRunAt) return
+    
+    // 3. Use CURRENT client (Single Connection Architecture)
+    const client = this._client
+    if (!client) return
+
+    try {
+      const result = await Reaper.reap(client, this._config, this._leaseManager, this._strategy, this._logger)
+      
+      if (!result.locked) {
+        // Lock busy (someone else is reaping) -> Exponential Backoff
+        this._reaperCurrentInterval = Math.min(this._reaperCurrentInterval * 1.5, 600000) // max 10m
+      } else {
+        // Success (or just acquired lock) -> Reset to Base
+        this._reaperCurrentInterval = this._reaperBaseInterval
+      }
+
+      // Schedule next run with jitter
+      const jitter = Math.random() * (this._reaperCurrentInterval / 2)
+      this._reaperNextRunAt = now + this._reaperCurrentInterval + jitter
+      
+      if (result.killed > 0) {
+        this._logger(`Reaper: Killed ${result.killed} zombies`)
+      }
+    } catch (err) {
+      this._logger('Reap failed:', err.message)
+    }
+  }
+
+  async query(...args) {
+    const startedAt = Date.now()
+    this._safeHook('onQueryStart', { args, startedAt })
+    let retries = 0
+    while (true) {
+      try {
+        if (!this._client || this._isDead) {
+          await this.connect()
+        } else {
+          // Check heartbeat. If lease expired -> WAIT. If OK -> async update.
+          await this._heartbeatIfNeeded()
+        }
+
+        const res = await this._client.query(...args)
+        this._queryPrevDelay = 0
+        this._safeHook('onQueryEnd', { args, res, duration: Date.now() - startedAt })
+        return res
+
+      } catch (err) {
+        // If error is NOT retryable, throw immediately
+        if (!RetryStrategy.isRetryable(err) || retries >= this._retryStrategy.retries) {
+          this._safeHook('onQueryError', { args, err, duration: Date.now() - startedAt })
+          throw err
+        }
+        if (this._maxQueryRetryTimeMs > 0 && (Date.now() - startedAt) > this._maxQueryRetryTimeMs) {
+          this._safeHook('onQueryError', { args, err, duration: Date.now() - startedAt })
+          throw err
+        }
+        
+        retries++
+        const delay = RetryStrategy.getBackoff(
+          this._retryStrategy.minBackoff,
+          this._retryStrategy.maxBackoff,
+          this._queryPrevDelay
+        )
+        this._queryPrevDelay = delay
+        this._safeHook('onQueryRetry', { retries, delay, err })
+        this._logger(`Query Retry ${retries}/${this._retryStrategy.retries} after ${delay}ms: ${err.message}`)
+        
+        // Force reconnect on next loop
+        this._isDead = true
+        await this._disposeClient('query_error')
+        
+        await new Promise(res => setTimeout(res, delay))
+      }
+    }
+  }
+
+  async _heartbeatIfNeeded() {
+    if (!this._leaseManager) return
+    const gen = this._generation
+    const client = this._client
+    const now = Date.now()
+    const remaining = this._leaseExp - now
+    
+    // If lease has > 30s remaining, we are safe. Do nothing.
+    if (remaining > this._heartbeatSoftRemainingMs) return
+
+    // If lease is expired or close to expiring (< 30s), we need update.
+    // Use promise deduplication to avoid thundering herd.
+    if (!this._heartbeatPromise) {
+      this._heartbeatPromise = this._performHeartbeat(gen, client).finally(() => {
+        this._heartbeatPromise = null
+      })
+    }
+
+    // If lease is ALREADY expired (or < 5s safety margin), we MUST wait for update.
+    if (remaining < this._heartbeatHardWaitRemainingMs) {
+      await this._heartbeatPromise
+    } else {
+      // Otherwise, let it update in background (fire-and-forget)
+      // This is safe because we still have > 5s lease
+    }
+  }
+
+  async _performHeartbeat(gen, client) {
+    try {
+      if (!this._leaseManager) return
+      if (!client || client !== this._client) return
+      if (this._generation !== gen) return
+      const newExp = Date.now() + this._leaseTtlMs
+      const appName = this._leaseManager.generateAppName(newExp)
+      // Never interpolate appName into SQL. Use bind parameters.
+      const heartbeatQuery = this._client.query(`SELECT set_config('application_name', $1, false)`, [appName])
+      const timeout = new Promise((_, reject) => {
+        const e = new Error(`Heartbeat timed out after ${this._heartbeatTimeoutMs}ms`)
+        e.code = 'ETIMEDOUT'
+        setTimeout(() => reject(e), this._heartbeatTimeoutMs)
+      })
+      const res = await Promise.race([heartbeatQuery, timeout])
+      if (!res) throw new Error('Heartbeat failed: no result')
+      // Only update local lease if DB update succeeded.
+      if (this._generation === gen && client === this._client) {
+        this._leaseExp = newExp
+        this._safeHook('onHeartbeat', { gen })
+      }
+    } catch (err) {
+      this._logger('Heartbeat failed:', err.message)
+      this._safeHook('onHeartbeatFail', { gen, err })
+      // If we're in hard-wait territory and heartbeat fails, do NOT keep a client that
+      // is now invisible to other reapers (lease can expire). Default action: reconnect.
+      if (this._heartbeatErrorMode === 'throw') throw err
+      if (this._heartbeatErrorMode === 'reconnect') {
+        // In soft zone we already decided heartbeat matters. Don't limp along into expiry.
+        // If it's retryable, definitely reconnect. If it's non-retryable, reconnect won't help,
+        // but it's still safer than staying in an inconsistent lease state.
+        this._isDead = true
+        await this._disposeClient('heartbeat_failed')
+      }
+    }
+  }
+
+  _buildPgClientConfig(overrides = {}) {
+    const clientConfig = { ...this._config, ...overrides }
+    if (!clientConfig.query_timeout && this._defaultQueryTimeoutMs > 0) {
+      clientConfig.query_timeout = this._defaultQueryTimeoutMs
+    }
+    // Strip internal fields (keep pg config clean and future-proof)
+    const internalKeys = [
+      'library',
+      'reaper',
+      'reaperRunProbability',
+      'reaperErrorMode',
+      'connUtilization', // legacy alias
+      'minConnectionIdleTimeSec',
+      'maxIdleConnectionsToKill',
+      'retries',
+      'minBackoff',
+      'maxBackoff',
+      'serviceName',
+      'secret',
+      'debug',
+      'leaseTtlMs',
+      'heartbeatSoftRemainingMs',
+      'heartbeatHardWaitRemainingMs',
+      'heartbeatErrorMode',
+      'heartbeatTimeoutMs',
+      'reaperCooldownMs',
+      'leaseMode',
+      'applicationName',
+      'defaultQueryTimeoutMs',
+      'hooks',
+      'maxConnectRetryTimeMs',
+      'maxQueryRetryTimeMs',
+    ]
+    for (const k of internalKeys) delete clientConfig[k]
+    return clientConfig
+  }
+
+  async _disposeClient(reason, { bumpGeneration = true } = {}) {
+    if (bumpGeneration) this._generation++
+    const old = this._client
+    this._client = null
+    if (!old) return
+    try {
+      await old.end()
+    } catch (_) {
+      // ignore
+    }
+  }
+
+  _markDeadAndDispose(client, err, source) {
+    // Never throw from event handlers (Lambda crash safety).
+    this._isDead = true
+    // Invalidate any in-flight connect/heartbeat on older generations.
+    this._generation++
+    // Atomically detach the client if it is the current one.
+    if (this._client === client) {
+      this._client = null
+    }
+    if (err) {
+      const meta = {
+        code: err.code,
+        sqlstate: err.sqlstate,
+        errno: err.errno,
+        syscall: err.syscall,
+        address: err.address,
+        port: err.port,
+        severity: err.severity,
+        routine: err.routine,
+      }
+      this._logger(`WARN: pg client ${source} (swallowed):`, err.message || err.code, meta)
+      this._safeHook('onClientDead', { source, err, meta })
+    }
+    // Best-effort close; do not await.
+    try {
+      client.end().catch(() => {})
+    } catch (_) {}
+  }
+
+  async clean() {
+    // Try to close gracefully
+    await this._disposeClient('clean')
+  }
+  
+  async end() {
+    return this.clean()
+  }
+
+  getClient() {
+    return this._client
+  }
+}
+
+module.exports = ServerlessClient

package/lib/lease.js

@@ -0,0 +1,124 @@
+const crypto = require('crypto')
+
+/**
+ * Lease Manager
+ * Handles generation and verification of signed application_name strings.
+ * Format: "s=SERVICE;i=INSTANCE_ID;e=TIMESTAMP;g=HMAC"
+ * Short keys used to fit within Postgres 63-byte limit.
+ */
+class LeaseManager {
+  static APP_NAME_MAX_LEN = 63
+  static SIG_LEN = 11 // 8 bytes -> base64url w/o padding => 11 chars
+
+  /**
+   * @param {string} serviceName - The logical name of the service
+   * @param {string} instanceId - Unique ID of this client instance
+   * @param {string} secret - Shared secret for HMAC (e.g. DB password)
+   */
+  constructor(serviceName, instanceId, secret) {
+    // Keep instanceId compact and delimiter-safe.
+    this.instanceId = LeaseManager._sanitizeToken(instanceId || 'inst')
+    if (!secret) {
+      throw new Error('LeaseManager requires a non-empty secret')
+    }
+    if (Buffer.byteLength(String(secret), 'utf8') < 16) {
+      throw new Error('LeaseManager secret is too short; must be at least 16 bytes')
+    }
+    this.secret = secret
+    // Normalize serviceName so application_name ALWAYS fits into 63 bytes and is LIKE-safe.
+    this.serviceName = LeaseManager._normalizeServiceName(serviceName || 'sls_pg', this.instanceId)
+  }
+
+  /**
+   * Generates a signed application_name.
+   * @param {number} expirationTs - Unix timestamp (ms) when lease expires
+   * @returns {string} The formatted application_name
+   * @throws {Error} if generated name exceeds 63 bytes
+   */
+  generateAppName(expirationTs) {
+    // Format: s=...;i=...;e=...
+    const base = `s=${this.serviceName};i=${this.instanceId};e=${expirationTs}`
+    const sig = this._sign(base)
+    const result = `${base};g=${sig}`
+
+    // Hard guarantee: never exceed Postgres 63-byte truncation limit.
+    // If this fires, our normalization math is wrong.
+    if (result.length > LeaseManager.APP_NAME_MAX_LEN) {
+      throw new Error(`BUG: application_name too long (${result.length} > ${LeaseManager.APP_NAME_MAX_LEN}): ${result}`)
+    }
+
+    return result
+  }
+
+  /**
+   * Parses an application_name and verifies its signature and expiration.
+   * @param {string} appNameString
+   * @returns {Object|null} Parsed info if valid format & signature, else null
+   */
+  parseAndVerify(appNameString) {
+    if (!appNameString) return null
+
+    // Regex for: s=...;i=...;e=...;g=...
+    const match = appNameString.match(/^s=([^;]+);i=([^;]+);e=([^;]+);g=([^;]+)$/)
+    if (!match) return null
+
+    const [full, s, i, eStr, g] = match
+    const base = `s=${s};i=${i};e=${eStr}`
+    const expectedSig = this._sign(base)
+
+    // Timing-safe signature comparison
+    const bufG = Buffer.from(g, 'utf8')
+    const bufExpected = Buffer.from(expectedSig, 'utf8')
+    if (bufG.length !== bufExpected.length || !crypto.timingSafeEqual(bufG, bufExpected)) return null
+
+    const exp = parseInt(eStr, 10)
+    if (!Number.isFinite(exp)) return null
+    
+    return {
+      svc: s,
+      inst: i,
+      exp,
+      isExpired: Date.now() > exp,
+      isValidSignature: true
+    }
+  }
+
+  _sign(text) {
+    // Compact signature: take first 8 bytes of HMAC and encode as base64url (11 chars, no padding)
+    const buf = crypto.createHmac('sha256', this.secret).update(text).digest()
+    return buf.subarray(0, 8).toString('base64url')
+  }
+
+  static _sanitizeToken(s) {
+    // Remove delimiter characters used by our format and LIKE wildcards.
+    // Keep it deterministic and log-friendly.
+    return String(s).replace(/[^a-zA-Z0-9:_-]/g, '_')
+  }
+
+  static _normalizeServiceName(serviceName, instanceId) {
+    const original = String(serviceName || 'sls_pg')
+    const raw = LeaseManager._sanitizeToken(original)
+    const inst = LeaseManager._sanitizeToken(instanceId || 'inst')
+
+    // Total format:
+    // s=<svc>;i=<inst>;e=<13digits>;g=<sig>
+    // Fixed overhead excluding <svc>: "s="(2) + ";i="(3) + inst + ";e="(3) + 13 + ";g="(3) + SIG_LEN
+    // => 24 + instLen + SIG_LEN
+    const overhead = 24 + inst.length + LeaseManager.SIG_LEN
+    const maxSvcLen = Math.max(1, LeaseManager.APP_NAME_MAX_LEN - overhead)
+
+    // If sanitization changed the name, we must add a hash suffix to avoid accidental collisions
+    // (different originals mapping to the same sanitized token).
+    const needsHash = raw !== original
+    if (!needsHash && raw.length <= maxSvcLen) return raw
+
+    // Truncate with a short hash suffix to preserve uniqueness.
+    const hash = crypto.createHash('sha1').update(original).digest('hex').slice(0, 8)
+    if (maxSvcLen <= hash.length) return hash.slice(0, maxSvcLen)
+
+    const prefixLen = maxSvcLen - (hash.length + 1)
+    return `${raw.slice(0, prefixLen)}-${hash}`
+  }
+}
+
+module.exports = LeaseManager

package/lib/reaper.js

@@ -0,0 +1,117 @@
+/**
+ * Connection Reaper
+ * Safely kills zombie connections using Advisory Locks and Signed Leases.
+ */
+class Reaper {
+  // Namespace advisory locks to avoid collisions with other apps in same DB.
+  // 0x50474151 corresponds to "PGAQ" (pg-aequor) in ASCII.
+  static LOCK_NS = 0x50474151
+  /**
+   * Runs the reaping process.
+   * @param {Object} client - The connected pg.Client
+   * @param {Object} config - Config including database name
+   * @param {LeaseManager} leaseManager - For verifying leases
+   * @param {Object} strategy - { minConnIdleTimeSec, connUtilization }
+   * @param {Function} logger
+   */
+  static async reap(client, config, leaseManager, strategy, logger) {
+    const serviceName = leaseManager.serviceName
+    let locked = false
+    
+    // 1. Acquire Advisory Lock (Non-blocking)
+    // Use Postgres native hashtext() to get a consistent 64-bit lock ID from the service string.
+    // This avoids JS-side 32-bit hash collisions.
+    
+    try {
+      const lockRes = await client.query(
+        `SELECT pg_try_advisory_lock($1::int, hashtext($2)) as locked`,
+        [Reaper.LOCK_NS, serviceName]
+      )
+      if (lockRes.rows[0].locked !== true) {
+        logger(`Reaper[pid=${process.pid}]: Lock busy, skipping`)
+        return { locked: false, killed: 0 }
+      }
+      locked = true
+
+      // 2. Scan for zombies
+      const minIdle = strategy.minConnIdleTimeSec
+      
+      // Fetch idle connections that look like our service
+      // Exclude self (pg_backend_pid())
+      // Optimization: Filter by application_name prefix in SQL to reduce result set size.
+      const query = `
+        SELECT pid, application_name, extract(epoch from (now() - state_change)) as idle_time
+        FROM pg_stat_activity 
+        WHERE datname = current_database() 
+          AND state = 'idle' 
+          AND pid <> pg_backend_pid()
+          AND application_name LIKE $1 || '%'
+      `
+      
+      // Correctness > optimization: do not prefilter using untrusted application_name.
+      const res = await client.query(query, [`s=${leaseManager.serviceName};`])
+      const candidates = []
+
+      for (const row of res.rows) {
+        if (row.idle_time < minIdle) continue
+
+        const lease = leaseManager.parseAndVerify(row.application_name)
+        
+        if (!lease) {
+          // Invalid format or signature -> Unsafe to touch (could be neighbor with different secret)
+          continue
+        }
+
+        if (lease.isExpired) {
+          // Valid signature, but expired -> ZOMBIE
+          candidates.push({
+            pid: row.pid,
+            idle_time: Number(row.idle_time) || 0,
+            exp: lease.exp,
+          })
+        }
+        // else: Lease valid -> ACTIVE neighbor -> Do not kill
+      }
+
+      // 3. Terminate zombies
+      if (candidates.length > 0) {
+        // Deterministic: kill the "stale-est" first.
+        // Primary: oldest expiration (smallest exp) -> longest expired.
+        // Secondary: largest idle_time.
+        candidates.sort((a, b) => (a.exp - b.exp) || (b.idle_time - a.idle_time) || (a.pid - b.pid))
+
+        const limit = Math.max(1, Number(strategy.maxIdleConnectionsToKill) || 1)
+        const selected = candidates.slice(0, limit)
+        const pidsToKill = selected.map(x => x.pid)
+
+        // Log a compact reason line for debugging.
+        const meta = selected.map(x => `pid=${x.pid},idle=${Math.round(x.idle_time)}s,expDelta=${Math.round((Date.now() - x.exp) / 1000)}s`).join(' | ')
+        logger(`Reaper[pid=${process.pid}]: Killing ${pidsToKill.length} zombies: ${meta}`)
+        // Cast to int[] to be safe
+        await client.query(`SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE pid = ANY($1::int[])`, [pidsToKill])
+        return { locked: true, killed: pidsToKill.length }
+      }
+      
+      return { locked: true, killed: 0 }
+
+    } catch (err) {
+      logger(`Reaper[pid=${process.pid}] failed:`, err && (err.stack || err.message || err))
+      if (strategy && strategy.reaperErrorMode === 'throw') throw err
+      return { locked: false, killed: 0, error: err }
+    } finally {
+      // 4. Release Lock
+      if (locked) {
+        try {
+          await client.query(
+            `SELECT pg_advisory_unlock($1::int, hashtext($2))`,
+            [Reaper.LOCK_NS, serviceName]
+          )
+        } catch (_) { /* ignore unlock error */ }
+      }
+    }
+  }
+  // Removed _hashString method as we use DB-side hashtext()
+}
+
+module.exports = Reaper
+

package/lib/retry.js

@@ -0,0 +1,59 @@
+/**
+ * Retry Strategy & Error Classification
+ * Implements "Decorrelated Jitter" and safe error analysis.
+ */
+
+class RetryStrategy {
+  /**
+   * Determines if an error is a "dead connection" error that warrants a retry/reconnect.
+   * @param {Error} err
+   * @returns {boolean}
+   */
+  static isRetryable(err) {
+    const code = err && err.code
+    const msg = (err && err.message) || ''
+    const sqlstate = (err && (err.code || err.sqlstate)) || null
+
+    // 1) Node.js socket / transport codes (not SQLSTATE)
+    if (code === 'ECONNRESET' || code === 'EPIPE' || code === 'ETIMEDOUT' || code === 'ECONNREFUSED') return true
+    if (code === 'ENETUNREACH' || code === 'EHOSTUNREACH' || code === 'EAI_AGAIN') return true
+    if (code === 'ECONNABORTED' || code === 'EADDRINUSE') return true
+
+    // 2) SQLSTATE-first (stable)
+    // Class 08 — connection exception
+    if (typeof sqlstate === 'string' && sqlstate.length === 5 && sqlstate.startsWith('08')) return true
+
+    // Admin / crash / cannot continue
+    if (sqlstate === '57P01' || sqlstate === '57P02' || sqlstate === '57P03') return true
+
+    // Too many connections (can be transient under spiky concurrency)
+    if (sqlstate === '53300') return true
+
+    // Optional: transient concurrency failures (only safe if queries are idempotent)
+    // Keep disabled for now to avoid duplicating non-idempotent writes.
+    // if (sqlstate === '40001' || sqlstate === '40P01') return true
+
+    // 3) LAST-RESORT message fallbacks (keep minimal; remove over time)
+    if (msg.includes('Connection terminated unexpectedly')) return true
+    if (msg.includes('sorry, too many clients already')) return true
+
+    return false
+  }
+
+  /**
+   * Calculates backoff delay using "Decorrelated Jitter".
+   * sleep = min(cap, random(base, sleep * 3))
+   * @param {number} baseMs - Minimum wait
+   * @param {number} capMs - Maximum wait
+   * @param {number} previousDelay - The delay used in the previous attempt (or 0)
+   * @returns {number} ms to sleep
+   */
+  static getBackoff(baseMs, capMs, previousDelay) {
+    const prev = previousDelay || baseMs
+    const randRange = (min, max) => Math.floor(Math.random() * (max - min + 1)) + min
+    return Math.min(capMs, randRange(baseMs, prev * 3))
+  }
+}
+
+module.exports = RetryStrategy
+

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "pg-aequor",
+  "version": "0.1.0",
+  "description": "Crash-safe, coordination-aware PostgreSQL client for Serverless environments",
+  "main": "./index.js",
+  "types": "index.d.ts",
+  "author": "dimaq12",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/dimaq12/pg-aequor.git"
+  },
+  "bugs": {
+    "url": "https://github.com/dimaq12/pg-aequor/issues"
+  },
+  "homepage": "https://github.com/dimaq12/pg-aequor#readme",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18"
+  },
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "require": "./index.js"
+    }
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "lib/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node --test"
+  },
+  "peerDependencies": {
+    "pg": "^8.11.0"
+  },
+  "devDependencies": {
+    "pg": "^8.11.0"
+  }
+}