queen-mq 0.7.4 → 0.12.1

package/client-v2/Queen.js

@@ -10,6 +10,7 @@ import { QueueBuilder } from './builders/QueueBuilder.js'
 import { TransactionBuilder } from './builders/TransactionBuilder.js'
 import { StreamBuilder } from './stream/StreamBuilder.js'
 import { StreamConsumer } from './stream/StreamConsumer.js'
+import { Admin } from './admin/Admin.js'
 import { CLIENT_DEFAULTS } from './utils/defaults.js'
 import { validateUrl, validateUrls } from './utils/validation.js'
 import * as logger from './utils/logger.js'
@@ -19,6 +20,7 @@ export class Queen {
   #bufferManager
   #config
   #shutdownHandlers = []
+  #admin = null
 
   constructor(config = {}) {
     logger.log('Queen.constructor', { config: typeof config === 'object' && !Array.isArray(config) ? { ...config, urls: config.urls?.length || 0 } : { type: typeof config } })
@@ -75,7 +77,7 @@ export class Queen {
   }
 
   #createHttpClient() {
-    const { urls, timeoutMillis, retryAttempts, retryDelayMillis, loadBalancingStrategy, affinityHashRing, healthRetryAfterMillis, enableFailover } = this.#config
+    const { urls, timeoutMillis, retryAttempts, retryDelayMillis, loadBalancingStrategy, affinityHashRing, healthRetryAfterMillis, enableFailover, bearerToken } = this.#config
 
     if (urls.length === 1) {
       // Single server
@@ -83,7 +85,8 @@ export class Queen {
         baseUrl: urls[0],
         timeoutMillis,
         retryAttempts,
-        retryDelayMillis
+        retryDelayMillis,
+        bearerToken
       })
     }
 
@@ -97,11 +100,17 @@ export class Queen {
       timeoutMillis,
       retryAttempts,
       retryDelayMillis,
-      enableFailover
+      enableFailover,
+      bearerToken
     })
   }
 
   #setupGracefulShutdown() {
+    // Skip signal handlers in browser environment
+    if (typeof process === 'undefined' || typeof process.on !== 'function') {
+      return
+    }
+
     let signalReceivedCount = 0;
     const shutdown = async (signal) => {
       console.log(`\nReceived ${signal}, shutting down gracefully...`)
@@ -140,6 +149,21 @@ export class Queen {
     return new QueueBuilder(this, this.#httpClient, this.#bufferManager, name)
   }
 
+  // ===========================
+  // Admin API Entry Point
+  // ===========================
+
+  /**
+   * Get the Admin API for administrative and observability operations
+   * @returns {Admin} Admin API instance (lazily initialized, singleton)
+   */
+  get admin() {
+    if (!this.#admin) {
+      this.#admin = new Admin(this.#httpClient)
+    }
+    return this.#admin
+  }
+
   // ===========================
   // Transaction API
   // ===========================

package/client-v2/admin/Admin.js

@@ -0,0 +1,414 @@
+/**
+ * Admin API for Queen - Administrative and observability endpoints
+ * These APIs are typically used by dashboards and admin tools, not regular applications
+ */
+
+import * as logger from '../utils/logger.js'
+
+export class Admin {
+  #httpClient
+
+  constructor(httpClient) {
+    this.#httpClient = httpClient
+  }
+
+  // ===========================
+  // Resources API
+  // ===========================
+
+  /**
+   * Get system overview with queue counts, message stats, etc.
+   * @returns {Promise<object>}
+   */
+  async getOverview() {
+    logger.log('Admin.getOverview', {})
+    return this.#httpClient.get('/api/v1/resources/overview')
+  }
+
+  /**
+   * Get all namespaces
+   * @returns {Promise<object>}
+   */
+  async getNamespaces() {
+    logger.log('Admin.getNamespaces', {})
+    return this.#httpClient.get('/api/v1/resources/namespaces')
+  }
+
+  /**
+   * Get all tasks
+   * @returns {Promise<object>}
+   */
+  async getTasks() {
+    logger.log('Admin.getTasks', {})
+    return this.#httpClient.get('/api/v1/resources/tasks')
+  }
+
+  // ===========================
+  // Queues API
+  // ===========================
+
+  /**
+   * List all queues
+   * @param {object} params - Query parameters (limit, offset, search, etc.)
+   * @returns {Promise<object>}
+   */
+  async listQueues(params = {}) {
+    logger.log('Admin.listQueues', { params })
+    const queryString = this.#buildQueryString(params)
+    return this.#httpClient.get(`/api/v1/resources/queues${queryString}`)
+  }
+
+  /**
+   * Get queue details
+   * @param {string} name - Queue name
+   * @returns {Promise<object>}
+   */
+  async getQueue(name) {
+    logger.log('Admin.getQueue', { name })
+    return this.#httpClient.get(`/api/v1/resources/queues/${encodeURIComponent(name)}`)
+  }
+
+  /**
+   * Clear all messages from a queue
+   * @param {string} name - Queue name
+   * @param {string} [partition] - Optional partition to clear
+   * @returns {Promise<object>}
+   */
+  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}`)
+  }
+
+  /**
+   * Get all partitions
+   * @param {object} params - Query parameters (queue, limit, etc.)
+   * @returns {Promise<object>}
+   */
+  async getPartitions(params = {}) {
+    logger.log('Admin.getPartitions', { params })
+    const queryString = this.#buildQueryString(params)
+    return this.#httpClient.get(`/api/v1/resources/partitions${queryString}`)
+  }
+
+  // ===========================
+  // Messages API
+  // ===========================
+
+  /**
+   * List messages with filters
+   * @param {object} params - Query parameters (queue, partition, status, limit, offset, etc.)
+   * @returns {Promise<object>}
+   */
+  async listMessages(params = {}) {
+    logger.log('Admin.listMessages', { params })
+    const queryString = this.#buildQueryString(params)
+    return this.#httpClient.get(`/api/v1/messages${queryString}`)
+  }
+
+  /**
+   * Get a specific message
+   * @param {string} partitionId - Partition ID
+   * @param {string} transactionId - Transaction ID
+   * @returns {Promise<object>}
+   */
+  async getMessage(partitionId, transactionId) {
+    logger.log('Admin.getMessage', { partitionId, transactionId })
+    return this.#httpClient.get(`/api/v1/messages/${partitionId}/${transactionId}`)
+  }
+
+  /**
+   * Delete a specific message
+   * @param {string} partitionId - Partition ID
+   * @param {string} transactionId - Transaction ID
+   * @returns {Promise<object>}
+   */
+  async deleteMessage(partitionId, transactionId) {
+    logger.log('Admin.deleteMessage', { partitionId, transactionId })
+    return this.#httpClient.delete(`/api/v1/messages/${partitionId}/${transactionId}`)
+  }
+
+  /**
+   * Retry a failed message
+   * @param {string} partitionId - Partition ID
+   * @param {string} transactionId - Transaction ID
+   * @returns {Promise<object>}
+   */
+  async retryMessage(partitionId, transactionId) {
+    logger.log('Admin.retryMessage', { partitionId, transactionId })
+    return this.#httpClient.post(`/api/v1/messages/${partitionId}/${transactionId}/retry`, {})
+  }
+
+  /**
+   * Move a message to the Dead Letter Queue
+   * @param {string} partitionId - Partition ID
+   * @param {string} transactionId - Transaction ID
+   * @returns {Promise<object>}
+   */
+  async moveMessageToDLQ(partitionId, transactionId) {
+    logger.log('Admin.moveMessageToDLQ', { partitionId, transactionId })
+    return this.#httpClient.post(`/api/v1/messages/${partitionId}/${transactionId}/dlq`, {})
+  }
+
+  // ===========================
+  // Traces API
+  // ===========================
+
+  /**
+   * Get traces by name
+   * @param {string} traceName - Trace name to search for
+   * @param {object} params - Query parameters (limit, offset, from, to, etc.)
+   * @returns {Promise<object>}
+   */
+  async getTracesByName(traceName, params = {}) {
+    logger.log('Admin.getTracesByName', { traceName, params })
+    const queryString = this.#buildQueryString(params)
+    return this.#httpClient.get(`/api/v1/traces/by-name/${encodeURIComponent(traceName)}${queryString}`)
+  }
+
+  /**
+   * Get available trace names
+   * @param {object} params - Query parameters (limit, search, etc.)
+   * @returns {Promise<object>}
+   */
+  async getTraceNames(params = {}) {
+    logger.log('Admin.getTraceNames', { params })
+    const queryString = this.#buildQueryString(params)
+    return this.#httpClient.get(`/api/v1/traces/names${queryString}`)
+  }
+
+  /**
+   * Get traces for a specific message
+   * @param {string} partitionId - Partition ID
+   * @param {string} transactionId - Transaction ID
+   * @returns {Promise<object>}
+   */
+  async getTracesForMessage(partitionId, transactionId) {
+    logger.log('Admin.getTracesForMessage', { partitionId, transactionId })
+    return this.#httpClient.get(`/api/v1/traces/${partitionId}/${transactionId}`)
+  }
+
+  // ===========================
+  // Analytics/Status API
+  // ===========================
+
+  /**
+   * Get system status
+   * @param {object} params - Query parameters
+   * @returns {Promise<object>}
+   */
+  async getStatus(params = {}) {
+    logger.log('Admin.getStatus', { params })
+    const queryString = this.#buildQueryString(params)
+    return this.#httpClient.get(`/api/v1/status${queryString}`)
+  }
+
+  /**
+   * Get queue statistics
+   * @param {object} params - Query parameters (limit, offset, etc.)
+   * @returns {Promise<object>}
+   */
+  async getQueueStats(params = {}) {
+    logger.log('Admin.getQueueStats', { params })
+    const queryString = this.#buildQueryString(params)
+    return this.#httpClient.get(`/api/v1/status/queues${queryString}`)
+  }
+
+  /**
+   * Get detailed statistics for a specific queue
+   * @param {string} name - Queue name
+   * @param {object} params - Query parameters
+   * @returns {Promise<object>}
+   */
+  async getQueueDetail(name, params = {}) {
+    logger.log('Admin.getQueueDetail', { name, params })
+    const queryString = this.#buildQueryString(params)
+    return this.#httpClient.get(`/api/v1/status/queues/${encodeURIComponent(name)}${queryString}`)
+  }
+
+  /**
+   * Get analytics data
+   * @param {object} params - Query parameters (from, to, interval, etc.)
+   * @returns {Promise<object>}
+   */
+  async getAnalytics(params = {}) {
+    logger.log('Admin.getAnalytics', { params })
+    const queryString = this.#buildQueryString(params)
+    return this.#httpClient.get(`/api/v1/status/analytics${queryString}`)
+  }
+
+  // ===========================
+  // Consumer Groups API
+  // ===========================
+
+  /**
+   * List all consumer groups
+   * @returns {Promise<object>}
+   */
+  async listConsumerGroups() {
+    logger.log('Admin.listConsumerGroups', {})
+    return this.#httpClient.get('/api/v1/consumer-groups')
+  }
+
+  /**
+   * Refresh consumer group statistics
+   * @returns {Promise<object>}
+   */
+  async refreshConsumerStats() {
+    logger.log('Admin.refreshConsumerStats', {})
+    return this.#httpClient.post('/api/v1/stats/refresh', {})
+  }
+
+  /**
+   * Get consumer group details
+   * @param {string} name - Consumer group name
+   * @returns {Promise<object>}
+   */
+  async getConsumerGroup(name) {
+    logger.log('Admin.getConsumerGroup', { name })
+    return this.#httpClient.get(`/api/v1/consumer-groups/${encodeURIComponent(name)}`)
+  }
+
+  /**
+   * Get lagging consumer groups
+   * @param {number} [minLagSeconds=60] - Minimum lag in seconds to be considered lagging
+   * @returns {Promise<object>}
+   */
+  async getLaggingConsumers(minLagSeconds = 60) {
+    logger.log('Admin.getLaggingConsumers', { minLagSeconds })
+    return this.#httpClient.get(`/api/v1/consumer-groups/lagging?minLagSeconds=${minLagSeconds}`)
+  }
+
+  /**
+   * Delete a consumer group for a specific queue
+   * @param {string} consumerGroup - Consumer group name
+   * @param {string} queueName - Queue name
+   * @param {boolean} [deleteMetadata=true] - Whether to delete subscription metadata
+   * @returns {Promise<object>}
+   */
+  async deleteConsumerGroupForQueue(consumerGroup, queueName, deleteMetadata = true) {
+    logger.log('Admin.deleteConsumerGroupForQueue', { consumerGroup, queueName, deleteMetadata })
+    const url = `/api/v1/consumer-groups/${encodeURIComponent(consumerGroup)}/queues/${encodeURIComponent(queueName)}?deleteMetadata=${deleteMetadata}`
+    return this.#httpClient.delete(url)
+  }
+
+  /**
+   * Seek consumer group offset for a queue
+   * @param {string} consumerGroup - Consumer group name
+   * @param {string} queueName - Queue name
+   * @param {object} options - Seek options (timestamp, position, etc.)
+   * @returns {Promise<object>}
+   */
+  async seekConsumerGroup(consumerGroup, queueName, options = {}) {
+    logger.log('Admin.seekConsumerGroup', { consumerGroup, queueName, options })
+    const url = `/api/v1/consumer-groups/${encodeURIComponent(consumerGroup)}/queues/${encodeURIComponent(queueName)}/seek`
+    return this.#httpClient.post(url, options)
+  }
+
+  // ===========================
+  // System API
+  // ===========================
+
+  /**
+   * Health check
+   * @returns {Promise<object>}
+   */
+  async health() {
+    logger.log('Admin.health', {})
+    return this.#httpClient.get('/health')
+  }
+
+  /**
+   * Get Prometheus metrics
+   * @returns {Promise<string>} Raw metrics text
+   */
+  async metrics() {
+    logger.log('Admin.metrics', {})
+    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.)
+   * @returns {Promise<object>}
+   */
+  async getSystemMetrics(params = {}) {
+    logger.log('Admin.getSystemMetrics', { params })
+    const queryString = this.#buildQueryString(params)
+    return this.#httpClient.get(`/api/v1/analytics/system-metrics${queryString}`)
+  }
+
+  /**
+   * Get worker metrics
+   * @param {object} params - Query parameters
+   * @returns {Promise<object>}
+   */
+  async getWorkerMetrics(params = {}) {
+    logger.log('Admin.getWorkerMetrics', { params })
+    const queryString = this.#buildQueryString(params)
+    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
+  // ===========================
+
+  #buildQueryString(params) {
+    const searchParams = new URLSearchParams()
+    for (const [key, value] of Object.entries(params)) {
+      if (value !== undefined && value !== null) {
+        searchParams.append(key, String(value))
+      }
+    }
+    const queryString = searchParams.toString()
+    return queryString ? `?${queryString}` : ''
+  }
+}
+

package/client-v2/admin/index.js

@@ -0,0 +1,6 @@
+/**
+ * Admin module exports
+ */
+
+export { Admin } from './Admin.js'
+

package/client-v2/builders/TransactionBuilder.js

@@ -13,10 +13,10 @@ export class TransactionBuilder {
     this.#httpClient = httpClient
   }
 
-  ack(messages, status = 'completed') {
+  ack(messages, status = 'completed', context = {}) {
     const msgs = Array.isArray(messages) ? messages : [messages]
     
-    logger.log('TransactionBuilder.ack', { count: msgs.length, status })
+    logger.log('TransactionBuilder.ack', { count: msgs.length, status, consumerGroup: context.consumerGroup })
 
     msgs.forEach(msg => {
       const transactionId = typeof msg === 'string' ? msg : (msg.transactionId || msg.id)
@@ -32,12 +32,19 @@ export class TransactionBuilder {
         throw new Error('Message must have partitionId property to ensure message uniqueness')
       }
 
-      this.#operations.push({
+      const operation = {
         type: 'ack',
         transactionId,
         partitionId,
         status
-      })
+      }
+
+      // Add consumerGroup if provided in context
+      if (context.consumerGroup) {
+        operation.consumerGroup = context.consumerGroup
+      }
+
+      this.#operations.push(operation)
 
       if (leaseId) {
         this.#requiredLeases.push(leaseId)

package/client-v2/http/HttpClient.js

@@ -11,6 +11,7 @@ export class HttpClient {
   #retryAttempts
   #retryDelayMillis
   #enableFailover
+  #bearerToken
 
   constructor(options = {}) {
     const {
@@ -19,7 +20,8 @@ export class HttpClient {
       timeoutMillis = 30000,
       retryAttempts = 3,
       retryDelayMillis = 1000,
-      enableFailover = true
+      enableFailover = true,
+      bearerToken = null
     } = options
 
     this.#baseUrl = baseUrl
@@ -28,13 +30,15 @@ export class HttpClient {
     this.#retryAttempts = retryAttempts
     this.#retryDelayMillis = retryDelayMillis
     this.#enableFailover = enableFailover
+    this.#bearerToken = bearerToken
     
     logger.log('HttpClient.constructor', { 
       hasLoadBalancer: !!loadBalancer, 
       baseUrl: baseUrl || 'load-balanced', 
       timeoutMillis, 
       retryAttempts,
-      enableFailover 
+      enableFailover,
+      hasAuth: !!bearerToken
     })
   }
 
@@ -46,10 +50,15 @@ export class HttpClient {
     const timeoutId = setTimeout(() => controller.abort(), effectiveTimeout)
 
     try {
+      const headers = { 'Content-Type': 'application/json' }
+      if (this.#bearerToken) {
+        headers['Authorization'] = `Bearer ${this.#bearerToken}`
+      }
+
       const options = {
         method,
         signal: controller.signal,
-        headers: { 'Content-Type': 'application/json' }
+        headers
       }
 
       if (body) {

package/client-v2/index.js

@@ -3,5 +3,6 @@
  */
 
 export { Queen } from './Queen.js'
+export { Admin } from './admin/Admin.js'
 export { CLIENT_DEFAULTS, QUEUE_DEFAULTS, CONSUME_DEFAULTS, POP_DEFAULTS, BUFFER_DEFAULTS } from './utils/defaults.js'
 

package/client-v2/utils/defaults.js

@@ -13,7 +13,8 @@ export const CLIENT_DEFAULTS = {
   loadBalancingStrategy: 'affinity',   // 'round-robin', 'session', or 'affinity'
   affinityHashRing: 128,               // Number of virtual nodes per server for affinity strategy
   enableFailover: true,                // Auto-failover to other servers
-  healthRetryAfterMillis: 5000        // Retry unhealthy backends after 5 seconds
+  healthRetryAfterMillis: 5000,        // Retry unhealthy backends after 5 seconds
+  bearerToken: null                    // Bearer token for proxy authentication
 }
 
 export const QUEUE_DEFAULTS = {

package/client-v2/utils/logger.js

@@ -1,9 +1,20 @@
 /**
  * Logger utility for Queen Client v2
- * Controlled by QUEEN_CLIENT_LOG environment variable
+ * Controlled by QUEEN_CLIENT_LOG environment variable (Node.js)
+ * or window.QUEEN_CLIENT_LOG (Browser)
  */
 
-const LOG_ENABLED = process.env.QUEEN_CLIENT_LOG === 'true'
+const LOG_ENABLED = (() => {
+  // Node.js environment
+  if (typeof process !== 'undefined' && process.env) {
+    return process.env.QUEEN_CLIENT_LOG === 'true'
+  }
+  // Browser environment
+  if (typeof window !== 'undefined') {
+    return window.QUEEN_CLIENT_LOG === true
+  }
+  return false
+})()
 
 /**
  * Get formatted timestamp

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "queen-mq",
-  "version": "0.7.4",
+  "version": "0.12.1",
   "type": "module",
   "description": "High-performance C++ message queue backed by PostgreSQL",
   "main": "client-v2/index.js",

package/test-v2/consume.js

@@ -51,60 +51,6 @@ export async function testConsumerTrace(client) {
     return { success: msgToReturn !== null, message: 'Consumer test completed successfully' }
 }
 
-export async function testConsumerNamespace(client) { 
-    const queue = await client.queue('test-queue-v2-namespace')
-    .namespace('test-namespace')
-    .create()
-    if (!queue.configured) {
-        return { success: false, message: 'Queue not created' }
-    }
-
-    await client
-    .queue('test-queue-v2-namespace')
-    .push([{ data: { message: 'Hello, world!' } }])
-
-    let msgToReturn = null
-
-    await client
-    .queue()
-    .namespace('test-namespace')
-    .batch(1)
-    .limit(1)
-    .each()
-    .consume(async msg => {
-        msgToReturn = msg
-    })
-
-    return { success: msgToReturn !== null, message: 'Consumer test completed successfully' }
-}
-
-export async function testConsumerTask(client) { 
-    const queue = await client.queue('test-queue-v2-task')
-    .task('test-task')
-    .create()
-    if (!queue.configured) {
-        return { success: false, message: 'Queue not created' }
-    }
-
-    await client
-    .queue('test-queue-v2-task')
-    .push([{ data: { message: 'Hello, world!' } }])
-
-    let msgToReturn = null
-
-    await client
-    .queue()
-    .task('test-task')
-    .batch(1)
-    .limit(1)
-    .each()
-    .consume(async msg => {
-        msgToReturn = msg
-    })
-
-    return { success: msgToReturn !== null, message: 'Consumer test completed successfully' }
-}
-
 export async function testConsumerWithPartition(client) { 
     const queue = await client.queue('test-queue-v2-consume-with-partition').create()
     if (!queue.configured) {
@@ -252,6 +198,7 @@ export async function testConsumerOrderingBatch(client) {
 
 
 export async function testConsumerBatchConsumeBatch(client) { 
+    await client.queue('test-queue-v2-consume-batch').delete()
     const queue = await client.queue('test-queue-v2-consume-batch').create()
     if (!queue.configured) {
         return { success: false, message: 'Queue not created' }
@@ -271,7 +218,7 @@ export async function testConsumerBatchConsumeBatch(client) {
     .queue('test-queue-v2-consume-batch')
     .batch(10)
     .wait(false)
-    .limit(1)
+    .limit(3)
     .consume(async msgs => {
         msgLength = msgs.length
     })
@@ -465,12 +412,13 @@ export async function manualAck(client) {
 
     await client
     .queue('test-queue-v2-manual-ack')
-    .concurrency(10)
+    .concurrency(1)
     .subscriptionMode('from_beginning')
     .batch(1000)
     .wait(false)
-    .limit(1)
+    .limit(10000)
     .consume(async msgs => {
+        console.log('Messages: ' + msgs.length)
         for (const msg of msgs) {
             if (lastId === null) {
                 lastId = msg.data.id
@@ -525,6 +473,7 @@ export async function retries(client) {
     .limit(300)  // Allow up to 300 messages (3 batches of 100)
     .consume(async msgs => {
         attemptCount++;
+        console.log('Attempt: ' + attemptCount)
         if (attemptCount < 3) {
             // Fail first 2 attempts, succeed on 3rd
             throw new Error('Test error - triggering retry')

package/test-v2/load.js

@@ -11,7 +11,7 @@ export async function testLoad(client) {
     let messages = [];
     for (let i = 0; i < messagesToPush; i++) {
         messages.push({ data: { id: i } })
-        if (messages.length >= 10000) {
+        if (messages.length >= 100) {
             await client.queue('test-queue-v2-load').push(messages)
             messages = [];
         }
@@ -24,11 +24,10 @@ export async function testLoad(client) {
     await client
     .queue('test-queue-v2-load')
     .concurrency(10)
-    .batch(10000)
+    .batch(100)
     .wait(false)
-    .limit(1)
+    .limit(10000)
     .consume(async msgs => {
-        console.log(`Messages: ${msgs.length}`)
         for (const msg of msgs) {
             if (lastId === null) {
                 lastId = msg.data.id
@@ -60,35 +59,37 @@ export async function testLoadPartition(client) {
 
     let messages = [];
     let k = 0
-    for (let i = 0; i < messagesToPush; i++) {
+    for (let k = 0; k < 10; k++) {
+    for (let i = 0; i < messagesToPush / 10; i++) {
         messages.push({ data: { id: i } })
-        if (messages.length >= 10000) {
+        if (messages.length >= 100) {
             await client
             .queue('test-queue-v2-load-partition')
             .partition(k.toString())
             .push(messages)
             messages = [];
-            k++;
         }
     }
-    await client.queue('test-queue-v2-load-partition').push(messages)    
+    }  
 
     let uniqueIds = new Set();
-    let lastId = null;
+    
     
     for (let i = 0; i < 10; i++) {
+        let lastId = null;
     await client
     .queue('test-queue-v2-load-partition')
     .partition(i.toString())
-    .batch(10000)
+    .batch(100)
     .wait(false)
-    .limit(1)
+    .limit(10000)
     .consume(async msgs => {
         for (const msg of msgs) {
             if (lastId === null) {
                 lastId = msg.data.id
             } else {
                 if (msg.data.id !== lastId + 1) {
+                    console.log(`Message ordering violation: ${msg.data.id} !== ${lastId + 1}`)
                     throw new Error('Message ordering violation')
                 }
                 lastId = msg.data.id
@@ -98,14 +99,15 @@ export async function testLoadPartition(client) {
     })
     }
 
+    console.log(uniqueIds.size, messagesToPush)
     const uniqueIdsCount = uniqueIds.size;
 
-    return { success: uniqueIdsCount === messagesToPush, message: 'Load test completed successfully' }
+    return { success: uniqueIdsCount === messagesToPush / 10, message: 'Load test completed successfully' }
 }
 
 export async function testLoadConsumerGroup(client) { 
     const queue = await client
-    .queue('test-queue-v2-load-consumer-group')
+    .queue('')
     .create()
     if (!queue.configured) {
         return { success: false, message: 'Queue not created' }
@@ -116,7 +118,7 @@ export async function testLoadConsumerGroup(client) {
     let messages = [];
     for (let i = 0; i < messagesToPush; i++) {
         messages.push({ data: { id: i } })
-        if (messages.length >= 10000) {
+        if (messages.length >= 100) {
             await client.queue('test-queue-v2-load-consumer-group').push(messages)
             messages = [];
         }
@@ -129,11 +131,11 @@ export async function testLoadConsumerGroup(client) {
     await client
     .queue('test-queue-v2-load-consumer-group')
     .group('test-consumer-group-a')
-    .subscriptionMode('from_beginning')
+    .subscriptionMode('all')
     .concurrency(10)
-    .batch(10000)
+    .batch(100)
     .wait(false)
-    .limit(1)
+    .limit(10000)
     .consume(async msgs => {
         for (const msg of msgs) {
             if (lastIdA === null) {
@@ -154,11 +156,11 @@ export async function testLoadConsumerGroup(client) {
     await client
     .queue('test-queue-v2-load-consumer-group')
     .group('test-consumer-group-b')
-    .subscriptionMode('from_beginning')
+    .subscriptionMode('all')
     .concurrency(10)
-    .batch(10000)
+    .batch(100)
     .wait(false)
-    .limit(1)
+    .limit(10000)
     .consume(async msgs => {
         for (const msg of msgs) {
             if (lastIdB === null) {

package/test-v2/maintenance.js

@@ -71,12 +71,14 @@ export async function test_maintenance_mode(client = null) {
             
             // Acknowledge messages
             await queen.ack(messages);
+            
           }
         } catch (err) {
           if (consumerActive) {
             console.error('  ❌ Consumer error:', err.message);
           }
         }
+        await sleep(10);
       }
     })();
     

package/test-v2/push.js

@@ -115,35 +115,6 @@ export async function pushBufferedMessage(client) {
     return { success: true }
 }
 
-export async function pushMaxQueueSize(client) {
-    const queue = await client.queue('test-queue-max-size').config({ maxSize: 10 }).create()
-    if (!queue.configured) {
-        return { success: false, message: 'Queue not created' }
-    }
-
-    // Necessary to create a partition consumer to trigger the capacity check
-    const popToCreateParititonConsumer = await client
-    .queue('test-queue-max-size')
-    .batch(1)
-    .wait(false)
-    .pop()    
-
-    try {
-        for (let i = 0; i < 20; i++) {
-        const result = await client
-        .queue('test-queue-max-size')
-        .push([{ data: { message: i } }])
-        }
-    } catch (error) {
-        if (!error.message.includes(' Queue "test-queue-max-size" would exceed max capacity (10).')) {
-            return { success: true, message: 'Correct error message' }
-        } else {
-            return { success: false, message: 'Incorrect error message' }
-        }
-    }
-    return { success: false }
-}
-
 export async function pushDelayedMessage(client) {
     const queue = await client.queue('test-queue-delayed')
     .config({ delayedProcessing: 2 })

package/test-v2/run.js

@@ -18,11 +18,26 @@ import * as bufferingTests from './ai_buffering.js'
 import * as priorityTests from './ai_priority.js'
 import * as ttlRetentionTests from './ai_ttl_retention.js'
 import * as mixedScenariosTests from './ai_mixed_scenarios.js'
+import { LoadBalancer } from '../client-v2/http/LoadBalancer.js';
 
 
 // Test configuration
-export const TEST_CONFIG = {
-  baseUrls: ['http://localhost:6632'],
+
+export const TEST_CONFIG_SINGLE = {
+    baseUrls: ['http://localhost:6632'],
+    loadBalancingStrategy: 'affinity',
+    dbConfig: {
+      host: process.env.PG_HOST || 'localhost',
+      port: process.env.PG_PORT || 5432,
+      database: process.env.PG_DB || 'postgres',
+      user: process.env.PG_USER || 'postgres',
+      password: process.env.PG_PASSWORD || 'postgres'
+    }
+  };
+
+export const TEST_CONFIG_MULTIPLE = {
+  baseUrls: ['http://localhost:6632','http://localhost:6633'],
+  loadBalancingStrategy: 'round-robin',
   dbConfig: {
     host: process.env.PG_HOST || 'localhost',
     port: process.env.PG_PORT || 5432,
@@ -32,6 +47,9 @@ export const TEST_CONFIG = {
   }
 };
 
+export const TEST_CONFIG = process.env.TEST_CONFIG === 'multiple' ? TEST_CONFIG_MULTIPLE : TEST_CONFIG_SINGLE;
+console.log('TEST_CONFIG:', TEST_CONFIG);
+
 // Global test state
 export let dbPool;  
 
@@ -82,7 +100,10 @@ export const cleanupTestData = async () => {
   };
 
 async function main() {
-    const client = new Queen(TEST_CONFIG.baseUrls)
+    const client = new Queen({
+        urls: TEST_CONFIG.baseUrls,
+        loadBalancingStrategy: TEST_CONFIG.loadBalancingStrategy
+    })
     await initDb()
 
     // Separate human and AI tests

package/test-v2/transaction.js

@@ -503,3 +503,69 @@ export async function transactionRollback(client) {
     }
 }
 
+export async function transactionAckWithConsumerGroup(client) {
+    const queueA = await client.queue('test-queue-v2-txn-cg-a').create()
+    const queueB = await client.queue('test-queue-v2-txn-cg-b').create()
+    if (!queueA.configured || !queueB.configured) {
+        return { success: false, message: 'Queues not created' }
+    }
+
+    const consumerGroup = 'test-consumer-group-txn'
+
+    // Push messages to queue A
+    await client.queue('test-queue-v2-txn-cg-a').push([
+        { data: { value: 1 } },
+        { data: { value: 2 } }
+    ])
+
+    // Pop with consumer group
+    const messages = await client.queue('test-queue-v2-txn-cg-a')
+        .group(consumerGroup)
+        .batch(2)
+        .wait(false)
+        .pop()
+
+    if (messages.length !== 2) {
+        return { success: false, message: `Expected 2 messages, got ${messages.length}` }
+    }
+
+    // Transaction: ACK with consumer group context, push to B
+    await client
+        .transaction()
+        .ack(messages[0], 'completed', { consumerGroup })
+        .ack(messages[1], 'completed', { consumerGroup })
+        .queue('test-queue-v2-txn-cg-b')
+        .push([{ data: { sum: messages[0].data.value + messages[1].data.value } }])
+        .commit()
+
+    // Verify: Pop again with same consumer group should get no messages
+    // (consumer group cursor should have advanced)
+    const messagesAfterAck = await client.queue('test-queue-v2-txn-cg-a')
+        .group(consumerGroup)
+        .batch(2)
+        .wait(false)
+        .pop()
+
+    // Verify: Queue B has the result
+    const resultB = await client.queue('test-queue-v2-txn-cg-b').batch(1).wait(false).pop()
+
+    // Verify: Using a different consumer group should still see the messages
+    const messagesOtherGroup = await client.queue('test-queue-v2-txn-cg-a')
+        .group('other-consumer-group')
+        .batch(2)
+        .wait(false)
+        .pop()
+
+    const success = messagesAfterAck.length === 0 && 
+                    resultB.length === 1 && 
+                    resultB[0].data.sum === 3 &&
+                    messagesOtherGroup.length === 2
+
+    return { 
+        success,
+        message: success 
+            ? 'Transaction ack with consumer group completed - cursor advanced correctly'
+            : `Failed: afterAck=${messagesAfterAck.length} (expected 0), resultB=${resultB.length} (expected 1), otherGroup=${messagesOtherGroup.length} (expected 2)`
+    }
+}
+