queen-mq 1.3.0 → 2.0.2

package/README.md

@@ -6,7 +6,7 @@
 
 [![npm](https://img.shields.io/npm/v/queen-mq.svg)](https://www.npmjs.com/package/queen-mq)
 [![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](LICENSE.md)
-[![Node](https://img.shields.io/badge/node-%3E%3D22.0.0-brightgreen.svg)](https://nodejs.org/)
+[![Node](https://img.shields.io/badge/node-%3E%3D24.0.0-brightgreen.svg)](https://nodejs.org/)
 
 [Quick Start](#quick-start) • [Complete Guide](client-v2/README.md) • [Examples](#examples) • [API Reference](#api-reference)
 
@@ -16,13 +16,13 @@
 
 ## What is Queen MQ?
 
-Queen MQ is a PostgreSQL-backed message queue system with a powerful feature set:
+Queen MQ is a partitioned message queue broker that keeps its state in its own replicated log, with a powerful feature set:
 
 - **FIFO Partitions** - Unlimited ordered partitions within queues
 - **Consumer Groups** - Kafka-style consumer groups for scalability
 - **Flexible Semantics** - Exactly-once, at-least-once, and at-most-once delivery
 - **Transactions** - Atomic operations across push and ack
-- **High Performance** — 104K msg/s push, 165K msg/s fan-out with consumer groups on a single 32-core node ([benchmarks](https://github.com/queen-mq/queen/tree/master/benchmark-queen/2026-04-26))
+- **High Performance** — 1M msg/s in and out of one queue of 10M partitions on three nodes ([benchmarks](https://queenmq.com/benchmarks/))
 - **Subscription Modes** - Process from beginning, new messages only, or from timestamp
 - **Dead Letter Queue** - Automatic failure handling and monitoring
 - **Message Tracing** - Debug distributed workflows with trace timelines
@@ -40,7 +40,7 @@ This client provides a fluent, promise-based API for Node.js applications.
 npm install queen-mq
 ```
 
-**Requirements:** Node.js 22+
+**Requirements:** Node.js 24+
 
 ---
 
@@ -133,20 +133,21 @@ await queen.queue('emails')
 
 ### Subscription Modes
 
-Control whether consumer groups process historical messages:
+Control whether consumer groups process historical messages. A group's mode is fixed the first
+time the group pops a queue; unset, it is the broker's `DEFAULT_SUBSCRIPTION_MODE`, which is `new`.
 
 ```javascript
-// Default: Process ALL messages (including backlog)
-await queen.queue('events')
-  .group('batch-analytics')
-  .consume(async (message) => { /* all messages */ })
-
-// Skip history, only new messages
+// Default ('new'): start where the group first pops, skip what is already there
 await queen.queue('events')
   .group('realtime-monitor')
-  .subscriptionMode('new')
   .consume(async (message) => { /* new only */ })
 
+// Process ALL messages, including the backlog
+await queen.queue('events')
+  .group('batch-analytics')
+  .subscriptionMode('all')
+  .consume(async (message) => { /* all messages */ })
+
 // Start from specific timestamp
 await queen.queue('events')
   .group('replay')
@@ -191,8 +192,8 @@ Notes:
   the partition cap; either way it is clamped to 64, so a conflating pop returns
   at most 64 messages per round-trip whatever `batch` says.
 - Refused with 400 by the broker without a `.group(...)`, and together with
-  `.autoAck(true)` (auto-ack commits at delivery, which would turn the guarantee
-  above into at-most-once).
+  `.commitOnDelivery()` (a commit at delivery would turn the guarantee above
+  into at-most-once). `pop()` raises that 400 instead of returning `[]`.
 - Requires broker **>= 1.1.0**. An older broker ignores the flag and would
   quietly deliver the whole backlog, so the SDK raises
   `conflation was requested but this broker did not apply it` on the first
@@ -278,6 +279,52 @@ await queen.queue('tasks')
   })
 ```
 
+**When the handler throws**, the consumer nacks what it was given (the message, or the whole batch)
+and keeps consuming. The broker redelivers it, and moves it to the dead letter queue once the queue's
+`retryLimit` is spent. With `.each()`, the later messages of the failed message's partition are
+skipped after a nack (the broker redelivers them too); the other partitions of the same pop are
+still handled.
+
+This is the same with `.autoAck(false)`. That setting hands the *success* path to your handler (it
+acks), not the failure path: a handler that threw never got to settle its messages. A message your
+handler acked before throwing is not affected: it is already settled, so the broker refuses
+its nack.
+
+To handle failures yourself, add `.onError(async (message, error) => { ... })`. The error then never
+reaches the consumer, nothing is nacked for you, and the message is yours to ack, nack, or leave
+until its lease expires. To stop consuming on an error, abort the `signal` you passed to
+`consume(handler, { signal })` from inside `onError`.
+
+```javascript
+// autoAck(false): the handler acks. A throw before the ack is nacked and retried.
+await queen.queue('tasks')
+  .group('workers')
+  .autoAck(false)
+  .each()                  // one message per call; without it the handler gets the popped array
+  .consume(async (message) => {
+    await processTask(message.data)
+    await queen.ack(message, true)
+  })
+
+// Your own failure policy: nack, then stop consuming.
+const stop = new AbortController()
+await queen.queue('tasks')
+  .group('workers')
+  .autoAck(false)
+  .each()
+  .consume(async (message) => {
+    await processTask(message.data)
+    await queen.ack(message, true)
+  }, { signal: stop.signal })
+  .onError(async (message, error) => {
+    await queen.ack(message, false, { error: error.message })
+    stop.abort()
+  })
+```
+
+Earlier versions stopped the consumer on a throw under `.autoAck(false)`: `consume()` rejected after
+the first failure, and the message stayed leased until its lease expired.
+
 ### Pop Messages (On-Demand Processing)
 
 ```javascript
@@ -494,9 +541,9 @@ Both surfaces are **always there**. There is nothing to enable: kv and timers ar
 broker the way push and pop are, on every cell that runs it. There is no capability to probe and
 no 404 that means "this cell does not have the feature" — a 404 from these routes is a bug.
 
-What an operator can still do is **pause** them, with the runtime kill switch in
-`queen.system_state` (`kv_enabled`, `timers_schedule_enabled`, `timers_fire_enabled`) — the same
-class of lever as maintenance mode, pulled live during an incident and expected to be pulled back.
+What an operator can still do is **pause** them, with the broker's runtime kill switches
+(`kv_enabled`, `timers_schedule_enabled`, `timers_fire_enabled`) — a lever pulled live during an
+incident and expected to be pulled back.
 A paused surface answers `503` with `Retry-After` and `error: 'kv_disabled'` / `'timers_disabled'`,
 which this client retries like any other 5xx. Inside a transaction it is a `403` on the `kv` or
 `timers` rider instead, so a bundle holding messages does not spin forever on a paused cell.
@@ -581,7 +628,7 @@ the retry budget.
 
 Durations that can be sub-second are in **milliseconds** (`delayMs`), the ones that cannot are in
 **seconds** (`ttlSeconds`). Only relative delays exist, because there is one clock and it is the
-database's. A delay in the past is legal and fires on the first cycle.
+broker's. A delay in the past is legal and fires on the first cycle.
 
 `deliverAt` is **"not before"**, never "exactly at".
 
@@ -748,8 +795,20 @@ const msgs = await queen.queue('q').batch(10).pop()
 const msgs = await queen.queue('q').batch(10).wait(true).pop()
 const msgs = await queen.queue('q').batch(200).partitions(50).pop()  // multi-partition pop
 const { messages, autopilot } = await queen.queue('q').popResult()   // + what the broker chose
+const msgs = await queen.queue('q').group('g').commitOnDelivery().pop()  // committed at delivery, nothing to ack
 ```
 
+A pop long-polls, waiting up to `timeoutMillis` (30 s) for a message, unless you call
+`.wait(false)`. Its messages come back leased, and the ack is yours.
+
+`.commitOnDelivery()` changes that for `pop()` and `popResult()`. The broker moves the group's
+cursor past the messages as it hands them out: there is no lease (`leaseId` is empty) and nothing
+to ack. This is at-most-once delivery: a crash after the pop loses the messages. The broker
+refuses it together with `.conflation()` (400). `consume()` always leases its messages, so it
+throws before any request when the builder has `.commitOnDelivery()`.
+
+`.autoAck()` is `consume()`'s ack after your handler and has no effect on a pop.
+
 ### Consume
 
 ```javascript
@@ -768,6 +827,11 @@ await queen.ack(message, false, { error: 'reason' })
 await queen.ack([msg1, msg2], true)  // Batch ack
 ```
 
+An ack is judged against the lease of the consumer group the message was popped under. `queen.ack()`
+and `transaction().ack()` take that group from the message (`message.consumerGroup`, which every pop
+returns) unless you name one: `{ group }` on `queen.ack()`, `{ consumerGroup }` or `{ group }` on a
+transaction. A batch ack carries a single group, so `queen.ack()` throws on a batch that mixes groups.
+
 ### Transactions
 
 ```javascript
@@ -816,11 +880,14 @@ await queen.timer(q).list({ limit: 50, after })                  // {rows, trunc
 ### Lease Renewal
 
 ```javascript
-await queen.renew(message)
-await queen.renew([msg1, msg2, msg3])
+await queen.renew(message)              // {leaseId, success, newExpiresAt, renewed}
+await queen.renew([msg1, msg2, msg3])   // one result per distinct lease
 await queen.queue('q').renewLease(true, 60000).consume(async (msg) => { /* auto-renew */ })
 ```
 
+`success: false` (with an `error`) means nothing was renewed: the lease expired, an ack or nack
+already released it, or it never existed. The messages it covered may already be redelivered.
+
 ### Buffering
 
 ```javascript
@@ -896,6 +963,18 @@ await queen.close()  // Flush buffers and close connections
 the broker. These values are what comes back with `.autopilot(false)` or
 `QUEEN_SDK_POP_AUTOPILOT=off`.
 
+### Pop Defaults
+
+```javascript
+{
+  batch: 1,              // autopilot OFF only, as for consume
+  wait: true,            // long-polls; .wait(false) returns at once
+  timeoutMillis: 30000,  // the long-poll limit
+  autoAck: false,        // consume()'s ack after the handler; no effect on pop()
+  commitOnDelivery: false // leased; .commitOnDelivery() commits at delivery (at-most-once)
+}
+```
+
 ---
 
 ## Logging
@@ -970,4 +1049,3 @@ const messages: Message<OrderData>[] = await queen.queue('orders').pop()
 ## License
 
 Apache 2.0 - See [LICENSE.md](../LICENSE.md)
-

package/client-v2/Queen.js

@@ -15,6 +15,7 @@ import { StreamBuilder } from './stream/StreamBuilder.js'
 import { StreamConsumer } from './stream/StreamConsumer.js'
 import { Admin } from './admin/Admin.js'
 import { popAutopilotDisabledByEnv } from './utils/autopilot.js'
+import { consumerGroupOf, sharedConsumerGroupOf } from './utils/consumerGroup.js'
 import { CLIENT_DEFAULTS } from './utils/defaults.js'
 import { validateUrl, validateUrls } from './utils/validation.js'
 import * as logger from './utils/logger.js'
@@ -28,9 +29,9 @@ const CLOSE_FLUSH_DEADLINE_MILLIS = 30000
 // Both /api/v1/ack and /api/v1/ack/batch respond with a top-level JSON array,
 // one item per acknowledgment in request order:
 //   [{index, transactionId, success, error, queueName, partitionName, leaseReleased, dlq}]
-// (see queen.ack_messages_v2 / routes/ack.cpp). A rejected ack/nack (e.g.
-// "Invalid or expired lease") still arrives as HTTP 200 with success=false on
-// the item, so the per-item flag is the only signal that the broker accepted it.
+// A rejected ack/nack (e.g. "Invalid or expired lease") still arrives as HTTP
+// 200 with success=false on the item, so the per-item flag is the only signal
+// that the broker accepted it.
 
 function normalizeAckItem(item, index) {
   if (item === null || typeof item !== 'object') {
@@ -61,6 +62,30 @@ function parseAckResults(result, expected) {
   throw new Error('Unexpected ack response format: missing per-item result array')
 }
 
+// POST /api/v1/lease/:leaseId/extend answers HTTP 200 whether or not anything
+// was renewed, so `success` in the body is the only signal:
+//   1.x and 2.x brokers: {leaseId, success, renewed, newExpiresAt, expiresAt, lease_expires_at}
+//   the C++ broker:      [{index, leaseId, success, error, expiresAt}]
+// success:false means the lease is gone (expired, released by an ack or nack,
+// or never existed): nothing was extended, and the messages it covered can
+// already be on their way to another consumer.
+function parseRenewResult(result, leaseId) {
+  const item = Array.isArray(result) ? result[0] : result
+  if (item === null || typeof item !== 'object') {
+    return { leaseId, success: false, newExpiresAt: null, error: 'Unexpected lease renewal response' }
+  }
+  const newExpiresAt = item.newExpiresAt ?? item.expiresAt ?? item.lease_expires_at ?? null
+  const success = typeof item.success === 'boolean' ? item.success : newExpiresAt !== null
+  const outcome = { leaseId, success, newExpiresAt }
+  if (typeof item.renewed === 'number') outcome.renewed = item.renewed
+  if (!success) {
+    outcome.error = typeof item.error === 'string' && item.error.length > 0
+      ? item.error
+      : 'Lease not renewed: it expired, was released by an ack or nack, or does not exist'
+  }
+  return outcome
+}
+
 export class Queen {
   #httpClient
   #bufferManager
@@ -294,8 +319,8 @@ export class Queen {
    *     creates it, which is what makes thousands of short-lived req/reply
    *     inboxes cheap (§1.1).
    *   * delivery is at-least-once while the owning broker lives, at-most-once
-   *     with `autoAck` (§1.3) -- NOT "at most once" as a class. Consumers still
-   *     need idempotency.
+   *     with `commitOnDelivery` (§1.3) -- NOT "at most once" as a class.
+   *     Consumers still need idempotency.
    *   * consumption semantics are the pop's `group`, exactly as on durable
    *     queues (§1.5): same group competes, own group fans out, no group is
    *     queue mode. There is no queue-level mode to set.
@@ -438,11 +463,15 @@ export class Queen {
         })
       }
 
+      // The group the messages were popped under unless the caller names one:
+      // the lease every ack has to match belongs to it (utils/consumerGroup.js).
+      const consumerGroup = context.group || sharedConsumerGroupOf(message)
+
       // Call batch ack endpoint
       try {
         const result = await this.#httpClient.post('/api/v1/ack/batch', {
           acknowledgments,
-          consumerGroup: context.group || null
+          consumerGroup
         })
 
         const results = parseAckResults(result, acknowledgments.length)
@@ -487,7 +516,9 @@ export class Queen {
       partitionId,
       status: statusStr,
       error: context.error || null,
-      consumerGroup: context.group || null
+      // The group the message was popped under unless the caller names one
+      // (utils/consumerGroup.js).
+      consumerGroup: context.group || consumerGroupOf(message)
     }
 
     if (leaseId) body.leaseId = leaseId
@@ -529,8 +560,8 @@ export class Queen {
     }
 
     // Dedupe: with v4 multi-partition pop, all messages in one batch share
-    // the same leaseId (one renew_lease_v2 call extends every claimed
-    // partition_consumers row). Without this, callers passing the full
+    // the same leaseId (one renew call extends the lease of every claimed
+    // partition). Without this, callers passing the full
     // messages array would issue N redundant identical HTTP calls.
     leaseIds = [...new Set(leaseIds)]
 
@@ -545,12 +576,13 @@ export class Queen {
     for (const leaseId of leaseIds) {
       try {
         const result = await this.#httpClient.post(`/api/v1/lease/${leaseId}/extend`, {})
-        results.push({
-          leaseId,
-          success: true,
-          newExpiresAt: result.leaseId ? result.newExpiresAt : result.lease_expires_at
-        })
-        logger.log('Queen.renew', { leaseId, success: true })
+        const outcome = parseRenewResult(result, leaseId)
+        results.push(outcome)
+        if (outcome.success) {
+          logger.log('Queen.renew', { leaseId, success: true, renewed: outcome.renewed })
+        } else {
+          logger.error('Queen.renew', { leaseId, error: outcome.error })
+        }
       } catch (error) {
         results.push({ leaseId, success: false, error: error.message })
         logger.error('Queen.renew', { leaseId, error: error.message })

package/client-v2/README.md

@@ -60,7 +60,7 @@ When connecting to multiple Queen servers, you can choose how requests are distr
 
 #### Affinity Mode (Recommended for Production)
 
-Uses consistent hashing with virtual nodes to route consumer groups to the same backend server. This optimizes database queries by consolidating poll intentions.
+Uses consistent hashing with virtual nodes to route consumer groups to the same backend server.
 
 ```javascript
 const queen = new Queen({
@@ -444,28 +444,31 @@ When a consumer group first subscribes to a queue, should it process **all histo
 - Join a stream at a specific point in time
 - Skip historical data for new analytics consumers
 
-### Default Behavior (All Messages)
+### Default Behavior (New Messages)
 
-By default, consumer groups start from the **beginning** and process all messages:
+By default, a consumer group starts where it first pops the queue and skips the messages that were
+already there. That default is the broker's `DEFAULT_SUBSCRIPTION_MODE`, which is `new`:
 
 ```javascript
-// This consumer group gets ALL messages, including historical ones
+// This consumer group gets only messages that arrive after it first pops
 await queen
   .queue('events')
   .group('new-analytics')
+  .each()
   .consume(async (message) => {
     console.log('Processing:', message.data)
   })
 ```
 
-**Server Default:** The server can be configured to change this default behavior:
+To process the backlog too, ask for it with `.subscriptionMode('all')`, or start the broker with
+`DEFAULT_SUBSCRIPTION_MODE=all` to make that the default for every new group:
 ```bash
-# Make all new consumer groups skip history by default
-export DEFAULT_SUBSCRIPTION_MODE="new"
-./bin/queen-server
+export DEFAULT_SUBSCRIPTION_MODE="all"
+./bin/queen
 ```
 
-When `DEFAULT_SUBSCRIPTION_MODE="new"` is set, new consumer groups automatically skip historical messages unless you explicitly override with `.subscriptionMode('all')`.
+The mode is stored with the group the first time it pops; changing the default later does not move
+an existing group.
 
 ### Subscription Mode: 'new'
 
@@ -1004,8 +1007,9 @@ const message = messages[0]
 
 // Start long processing
 const timer = setInterval(async () => {
-  await queen.renew(message)  // Extend lease
-  console.log('Lease renewed!')
+  const { success, newExpiresAt, error } = await queen.renew(message)  // Extend lease
+  if (success) console.log('Lease renewed until', newExpiresAt)
+  else console.warn('Lease lost:', error)   // expired or already released: it will be redelivered
 }, 30000)  // Every 30 seconds
 
 try {
@@ -1432,6 +1436,16 @@ await queen.queue('reports').consume(async (msg) => {
 
 Sometimes you need more control over what happens when messages succeed or fail.
 
+### What a Throw Does
+
+Without callbacks, a handler that throws gets what it was given nacked (the message with `.each()`,
+otherwise the whole popped batch), and the consumer keeps going. The broker redelivers it, and moves
+it to the DLQ once the queue's `retryLimit` is spent. That holds with `.autoAck(false)` too: there
+your handler acks on success, but a handler that threw never got to settle anything.
+
+With `.onError()` the failure is yours: nothing is nacked on your behalf. Ack, nack or DLQ the
+message in the callback, or it stays leased until its lease expires.
+
 ### Success Callback
 
 ```javascript
@@ -1457,6 +1471,7 @@ await queen
   .onError(async (message, error) => {
     console.error('Failed:', error.message)
     // Log to external service, send alert, etc.
+    await queen.ack(message, false)   // with onError, nothing is nacked for you
   })
 ```
 
@@ -1647,6 +1662,11 @@ const msgs = await queen.queue('q').partition('p1').pop()
 // capped at 200 total messages. All partitions share one leaseId.
 // Each returned message carries its own partitionId / partition / leaseId.
 const msgs = await queen.queue('q').batch(200).partitions(50).pop()
+
+// Commit at delivery: the broker moves the group's cursor past the messages
+// as it hands them out. No lease, nothing to ack, at-most-once: a crash after
+// the pop loses them. pop() and popResult() only; consume() throws.
+const msgs = await queen.queue('q').group('g').commitOnDelivery().pop()
 ```
 
 ### Consume
@@ -1900,8 +1920,9 @@ await queen.close()
 ```javascript
 {
   batch: 1,
-  wait: false,                        // No long polling
-  autoAck: false                      // Manual ack required
+  wait: true,                         // Long polling; .wait(false) returns at once
+  autoAck: false,                     // consume()'s ack after the handler; no effect on pop()
+  commitOnDelivery: false             // Manual ack required; .commitOnDelivery() commits at delivery
 }
 ```
 

package/client-v2/admin/Admin.js

@@ -101,15 +101,26 @@ export class Admin {
   }
 
   /**
-   * Clear all messages from a queue
+   * @deprecated The 2.x broker has no route that clears a queue, so this
+   *             always rejects, before any request. Seek each consumer group
+   *             to the end instead.
+   *
+   * The old DELETE /api/v1/queues/:name/clear answers 404 no_such_route on
+   * 2.x. A seek to the end moves one group's cursor past every queued message
+   * (and releases its live leases); the group of a pop without one is
+   * '__QUEUE_MODE__'. Deleting the queue is not a clear: it removes the queue
+   * itself, with its configuration.
    * @param {string} name - Queue name
-   * @param {string} [partition] - Optional partition to clear
-   * @returns {Promise<object>}
+   * @param {string} [partition] - Ignored
+   * @returns {Promise<never>}
    */
   async clearQueue(name, partition = null) {
     logger.log('Admin.clearQueue', { name, partition })
-    const queryString = partition ? `?partition=${encodeURIComponent(partition)}` : ''
-    return this.#httpClient.delete(`/api/v1/queues/${encodeURIComponent(name)}/clear${queryString}`)
+    throw new Error(
+      'Queen 2.x has no route that clears a queue. Move each consumer group past what is queued ' +
+      `with queen.admin.seekConsumerGroup(group, '${name}', { toEnd: true }); ` +
+      "a pop without a group reads as the group '__QUEUE_MODE__'."
+    )
   }
 
   /**
@@ -172,14 +183,25 @@ export class Admin {
   }
 
   /**
-   * Move a message to the Dead Letter Queue
+   * @deprecated The 2.x broker has no route that moves a message to the DLQ
+   *             by its address, so this always rejects, before any request.
+   *             Ack the leased message with the `dlq` status instead.
+   *
+   * The old POST /api/v1/messages/:partitionId/:transactionId/dlq answers 404
+   * no_such_route on 2.x. The broker files a dead letter when the consumer
+   * group acks the message with the `dlq` status while it holds the lease (an
+   * address alone cannot name the lease), or when a `failed` ack spends the
+   * queue's last retry.
    * @param {string} partitionId - Partition ID
    * @param {string} transactionId - Transaction ID
-   * @returns {Promise<object>}
+   * @returns {Promise<never>}
    */
   async moveMessageToDLQ(partitionId, transactionId) {
     logger.log('Admin.moveMessageToDLQ', { partitionId, transactionId })
-    return this.#httpClient.post(`/api/v1/messages/${partitionId}/${transactionId}/dlq`, {})
+    throw new Error(
+      'Queen 2.x has no route that moves a message to the DLQ by its address. Pop the message for ' +
+      "its consumer group and call queen.ack(message, 'dlq', { group }) while you hold its lease."
+    )
   }
 
   // ===========================
@@ -359,44 +381,6 @@ export class Admin {
     return this.#httpClient.get('/metrics')
   }
 
-  /**
-   * Get push maintenance mode status
-   * @returns {Promise<object>}
-   */
-  async getMaintenanceMode() {
-    logger.log('Admin.getMaintenanceMode', {})
-    return this.#httpClient.get('/api/v1/system/maintenance')
-  }
-
-  /**
-   * Set push maintenance mode
-   * @param {boolean} enabled - Enable or disable maintenance mode
-   * @returns {Promise<object>}
-   */
-  async setMaintenanceMode(enabled) {
-    logger.log('Admin.setMaintenanceMode', { enabled })
-    return this.#httpClient.post('/api/v1/system/maintenance', { enabled })
-  }
-
-  /**
-   * Get pop maintenance mode status
-   * @returns {Promise<object>}
-   */
-  async getPopMaintenanceMode() {
-    logger.log('Admin.getPopMaintenanceMode', {})
-    return this.#httpClient.get('/api/v1/system/maintenance/pop')
-  }
-
-  /**
-   * Set pop maintenance mode
-   * @param {boolean} enabled - Enable or disable pop maintenance mode
-   * @returns {Promise<object>}
-   */
-  async setPopMaintenanceMode(enabled) {
-    logger.log('Admin.setPopMaintenanceMode', { enabled })
-    return this.#httpClient.post('/api/v1/system/maintenance/pop', { enabled })
-  }
-
   /**
    * Get system metrics (CPU, memory, connections, etc.)
    * @param {object} params - Query parameters (from, to, etc.)
@@ -419,15 +403,6 @@ export class Admin {
     return this.#httpClient.get(`/api/v1/analytics/worker-metrics${queryString}`)
   }
 
-  /**
-   * Get PostgreSQL statistics
-   * @returns {Promise<object>}
-   */
-  async getPostgresStats() {
-    logger.log('Admin.getPostgresStats', {})
-    return this.#httpClient.get('/api/v1/analytics/postgres-stats')
-  }
-
   // ===========================
   // Helper Methods
   // ===========================