queen-mq 0.1.5 → 0.2.0

package/examples/multi-server-test.js

@@ -1,305 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Multi-Server Load Balancing Test
- * 
- * This script tests the Queen client with multiple servers using different
- * load balancing strategies (ROUND_ROBIN and SESSION).
- * 
- * Usage:
- * 1. Start two Queen servers on different ports:
- *    PORT=6632 node src/server.js
- *    PORT=6633 node src/server.js
- * 
- * 2. Run this test:
- *    node examples/multi-server-test.js
- */
-
-import { createQueenClient, LoadBalancingStrategy } from '../src/client/index.js';
-
-const servers = [
-  'http://localhost:6632',
-  'http://localhost:6633'
-];
-
-// Test configuration
-const TEST_QUEUE = 'multi-server-test';
-const TEST_NAMESPACE = 'load-balancing';
-
-// Helper to log with timestamp
-const log = (message, type = 'info') => {
-  const timestamp = new Date().toISOString();
-  const prefix = type === 'error' ? '❌' : type === 'success' ? '✅' : 'ℹ️';
-  console.log(`[${timestamp}] ${prefix} ${message}`);
-};
-
-// Test Round Robin strategy
-async function testRoundRobinStrategy() {
-  log('Testing ROUND_ROBIN load balancing strategy', 'info');
-  
-  const client = createQueenClient({
-    baseUrls: servers,
-    loadBalancingStrategy: LoadBalancingStrategy.ROUND_ROBIN,
-    enableFailover: true
-  });
-  
-  // Configure the queue
-  await client.configure({
-    queue: TEST_QUEUE,
-    namespace: TEST_NAMESPACE,
-    task: 'round-robin-test',
-    options: {
-      maxRetries: 3,
-      retryDelay: 1000
-    }
-  });
-  
-  // Push multiple messages to see round-robin distribution
-  const messages = [];
-  for (let i = 1; i <= 10; i++) {
-    messages.push({
-      queue: TEST_QUEUE,
-      partition: 'Default',
-      payload: { 
-        id: i, 
-        strategy: 'round-robin',
-        timestamp: Date.now() 
-      }
-    });
-  }
-  
-  log(`Pushing ${messages.length} messages with ROUND_ROBIN strategy`);
-  const pushResult = await client.push({ items: messages });
-  log(`Pushed messages: ${JSON.stringify(pushResult)}`, 'success');
-  
-  // Get load balancer stats
-  const stats = client.getLoadBalancerStats();
-  log(`Load balancer stats: ${JSON.stringify(stats, null, 2)}`);
-  
-  // Pop messages to verify they were stored
-  log('Popping messages to verify...');
-  const popResult = await client.pop({
-    queue: TEST_QUEUE,
-    batch: 5,
-    wait: false
-  });
-  
-  if (popResult.messages && popResult.messages.length > 0) {
-    log(`Retrieved ${popResult.messages.length} messages`, 'success');
-    
-    // Acknowledge messages
-    for (const msg of popResult.messages) {
-      await client.ack(msg.transactionId, 'completed');
-    }
-    log('Messages acknowledged', 'success');
-  } else {
-    log('No messages retrieved', 'warning');
-  }
-  
-  return client;
-}
-
-// Test Session affinity strategy
-async function testSessionStrategy() {
-  log('\nTesting SESSION load balancing strategy', 'info');
-  
-  const client = createQueenClient({
-    baseUrls: servers,
-    loadBalancingStrategy: LoadBalancingStrategy.SESSION,
-    enableFailover: true
-  });
-  
-  // Configure the queue
-  await client.configure({
-    queue: TEST_QUEUE,
-    namespace: TEST_NAMESPACE,
-    task: 'session-test',
-    options: {
-      maxRetries: 3,
-      retryDelay: 1000
-    }
-  });
-  
-  // Push multiple messages - should all go to the same server
-  const messages = [];
-  for (let i = 1; i <= 10; i++) {
-    messages.push({
-      queue: TEST_QUEUE,
-      partition: 'Session',
-      payload: { 
-        id: i, 
-        strategy: 'session',
-        timestamp: Date.now() 
-      }
-    });
-  }
-  
-  log(`Pushing ${messages.length} messages with SESSION strategy`);
-  const pushResult = await client.push({ items: messages });
-  log(`Pushed messages: ${JSON.stringify(pushResult)}`, 'success');
-  
-  // Get load balancer stats
-  const stats = client.getLoadBalancerStats();
-  log(`Load balancer stats: ${JSON.stringify(stats, null, 2)}`);
-  
-  // Pop messages to verify they were stored
-  log('Popping messages to verify...');
-  const popResult = await client.pop({
-    queue: TEST_QUEUE,
-    partition: 'Session',
-    batch: 5,
-    wait: false
-  });
-  
-  if (popResult.messages && popResult.messages.length > 0) {
-    log(`Retrieved ${popResult.messages.length} messages from session-affinity server`, 'success');
-    
-    // Acknowledge messages
-    for (const msg of popResult.messages) {
-      await client.ack(msg.transactionId, 'completed');
-    }
-    log('Messages acknowledged', 'success');
-  } else {
-    log('No messages retrieved', 'warning');
-  }
-  
-  return client;
-}
-
-// Test failover behavior
-async function testFailover() {
-  log('\nTesting failover behavior (requires one server to be down)', 'info');
-  
-  const client = createQueenClient({
-    baseUrls: [
-      'http://localhost:9999', // Non-existent server
-      'http://localhost:6632'  // Working server
-    ],
-    loadBalancingStrategy: LoadBalancingStrategy.ROUND_ROBIN,
-    enableFailover: true,
-    timeout: 5000 // Shorter timeout for testing
-  });
-  
-  try {
-    // Try to push a message - should failover to working server
-    log('Attempting to push message with one server down...');
-    const result = await client.push({
-      items: [{
-        queue: TEST_QUEUE,
-        partition: 'Failover',
-        payload: { test: 'failover', timestamp: Date.now() }
-      }]
-    });
-    
-    log('Message pushed successfully via failover!', 'success');
-    log(`Result: ${JSON.stringify(result)}`);
-    
-    // Get stats to see which server was used
-    const stats = client.getLoadBalancerStats();
-    log(`Load balancer stats after failover: ${JSON.stringify(stats, null, 2)}`);
-    
-  } catch (error) {
-    log(`Failover test failed: ${error.message}`, 'error');
-  }
-  
-  return client;
-}
-
-// Test WebSocket connections with multiple servers
-async function testWebSocketConnections() {
-  log('\nTesting WebSocket connections with multiple servers', 'info');
-  
-  const client = createQueenClient({
-    baseUrls: servers,
-    loadBalancingStrategy: LoadBalancingStrategy.ROUND_ROBIN
-  });
-  
-  // Create WebSocket connections to different servers
-  log('Creating WebSocket connections...');
-  
-  const ws1 = client.createWebSocketConnection('/ws/dashboard');
-  log(`WebSocket 1 connected to: ${ws1.serverUrl}`);
-  
-  const ws2 = client.createWebSocketConnection('/ws/dashboard');
-  log(`WebSocket 2 connected to: ${ws2.serverUrl}`);
-  
-  // Set up message handlers
-  ws1.onMessage((data) => {
-    log(`WS1 received: ${JSON.stringify(data)}`);
-  });
-  
-  ws2.onMessage((data) => {
-    log(`WS2 received: ${JSON.stringify(data)}`);
-  });
-  
-  // Keep connections open for a bit
-  await new Promise(resolve => setTimeout(resolve, 2000));
-  
-  // Close connections
-  ws1.close();
-  ws2.close();
-  log('WebSocket connections closed', 'success');
-  
-  return client;
-}
-
-// Test single server backward compatibility
-async function testBackwardCompatibility() {
-  log('\nTesting backward compatibility with single baseUrl', 'info');
-  
-  // Old style - single baseUrl
-  const client = createQueenClient({
-    baseUrl: 'http://localhost:6632',
-    timeout: 30000
-  });
-  
-  try {
-    const result = await client.push({
-      items: [{
-        queue: TEST_QUEUE,
-        partition: 'Compatibility',
-        payload: { test: 'backward-compatibility', timestamp: Date.now() }
-      }]
-    });
-    
-    log('Backward compatibility test passed!', 'success');
-    log(`Result: ${JSON.stringify(result)}`);
-    
-    // This should return null for single-server mode
-    const stats = client.getLoadBalancerStats();
-    log(`Load balancer stats (should be null): ${stats}`);
-    
-  } catch (error) {
-    log(`Backward compatibility test failed: ${error.message}`, 'error');
-  }
-  
-  return client;
-}
-
-// Main test runner
-async function runTests() {
-  console.log('=' .repeat(80));
-  console.log('Queen Multi-Server Load Balancing Test Suite');
-  console.log('=' .repeat(80));
-  
-  try {
-    // Test different strategies
-    await testRoundRobinStrategy();
-    await testSessionStrategy();
-    await testFailover();
-    await testWebSocketConnections();
-    await testBackwardCompatibility();
-    
-    console.log('\n' + '=' .repeat(80));
-    log('All tests completed!', 'success');
-    console.log('=' .repeat(80));
-    
-  } catch (error) {
-    log(`Test suite failed: ${error.message}`, 'error');
-    console.error(error);
-    process.exit(1);
-  }
-}
-
-// Run the tests
-runTests().catch(console.error);

package/examples/programmatic-server.js

@@ -1,58 +0,0 @@
-/**
- * Example: Starting Queen Server Programmatically
- * 
- * This example shows how to import and run the Queen server
- * directly from your code, rather than running it as a separate process.
- */
-
-import { QueenServer, Queen } from 'queen-mq';
-
-// Start the server programmatically
-console.log('Starting Queen Server...');
-
-const server = await QueenServer({
-  port: 3000,
-  host: '127.0.0.1'
-});
-
-console.log(`✅ Server started at http://${server.host}:${server.port}`);
-
-// Now you can use the client in the same process
-const client = new Queen({
-  servers: [`http://${server.host}:${server.port}`]
-});
-
-// Create a queue
-await client.push({
-  queue: 'example-queue',
-  items: [
-    { data: { message: 'Hello from programmatic server!' } }
-  ]
-});
-
-console.log('✅ Message pushed to queue');
-
-// Pop a message
-const result = await client.pop({
-  queue: 'example-queue'
-});
-
-console.log('✅ Message received:', result.messages[0]?.data);
-
-// Acknowledge the message
-if (result.messages.length > 0) {
-  await client.ack({
-    transactionId: result.messages[0].transactionId,
-    status: 'completed'
-  });
-  console.log('✅ Message acknowledged');
-}
-
-// Graceful shutdown on SIGINT
-process.on('SIGINT', async () => {
-  console.log('\nShutting down...');
-  await server.shutdown('SIGINT');
-});
-
-console.log('\n📝 Server is running. Press Ctrl+C to stop.');
-

package/examples/server-with-frontend.js

@@ -1,46 +0,0 @@
-/**
- * Example: Starting Queen Server with Built-in Frontend Dashboard
- * 
- * This example shows how to run Queen with the frontend dashboard
- * served from the same server (single deployment unit).
- * 
- * Prerequisites:
- * - Build the frontend first: cd webapp && npm run build
- */
-
-import { QueenServer } from '../src/server.js';
-
-console.log('Starting Queen Server with Frontend Dashboard...\n');
-
-const server = await QueenServer({
-  port: 3000,
-  host: '127.0.0.1',
-  serveWebapp: true  // 👈 Enable frontend serving
-});
-
-console.log('\n✅ Server started successfully!');
-console.log(`
-📊 Access Points:
-   - Frontend Dashboard: http://${server.host}:${server.port}/
-   - API Endpoint:      http://${server.host}:${server.port}/api/v1/
-   - Health Check:      http://${server.host}:${server.port}/health
-   - Metrics:           http://${server.host}:${server.port}/metrics
-
-🎯 Single Port Deployment:
-   Everything (frontend + API) served from port ${server.port}!
-   No CORS issues, no separate static file server needed.
-
-📝 To test:
-   1. Open http://${server.host}:${server.port}/ in your browser
-   2. You should see the Queen Dashboard UI
-   3. All API calls will work from the same origin
-
-Press Ctrl+C to stop.
-`);
-
-// Graceful shutdown
-process.on('SIGINT', async () => {
-  console.log('\n\nShutting down...');
-  await server.shutdown('SIGINT');
-});
-

package/examples/single.js

@@ -1,64 +0,0 @@
-import { createQueenClient } from '../src/client/index.js';
-
-const client = createQueenClient({
-    baseUrl: process.env.QUEEN_URL || 'http://localhost:6632',
-    timeout: 10000  // 10 second timeout for operations
-});
-
-// V2: Using queue and partition structure
-const queue = 'smartchat-agent';
-const partition = 'id-1';  // Can use partition to separate different agents
-
-async function consumer () {
-  // Start consuming messages from the specific partition
-  const stop = client.consume({
-    queue: queue,
-    partition: partition,  // Optional: remove to consume from any partition
-    handler: async (message) => {
-      console.log(`Consumed message from ${message.partition}: ${message.data.data}`);
-    },
-    options: {
-      wait: true,
-      timeout: 10000
-    }
-  });
-  
-  // Return stop function for cleanup if needed
-  return stop;
-}
-
-let count = 0;
-async function producer () {
-  const messages = [{
-    queue: queue,
-    partition: partition,  // Optional: defaults to "Default"
-    payload: {
-      id: count,
-      data: `Hello, world! ${count++}`,
-      timestamp: new Date().toISOString()
-    }
-  }];
-
-  const result = await client.push({
-    items: messages
-  });
-  console.log(`Pushed ${result.messages.length} messages to ${queue}/${partition}`);
-}
-
-// Start consumer
-consumer().then(stop => {
-  // Handle graceful shutdown
-  process.on('SIGINT', () => {
-    console.log('\nStopping consumer...');
-    stop();
-    process.exit(0);
-  });
-});
-
-// Start producer loop
-(async () => {
-  while (true) {
-    await producer();
-    await new Promise(resolve => setTimeout(resolve, 10000));
-  }
-})();

package/examples/smartchat-dealyed.js

@@ -1,42 +0,0 @@
-// Create client
-import fs from 'fs';
-import { createQueenClient } from '../src/client/index.js';
-
-const client = createQueenClient({
-    baseUrl: 'http://localhost:6632'
-});
-
-// Configure a queue with delayed processing
-await client.configure({
-    queue: 'htmls-delayed-02',
-    // partition parameter removed - all config is queue-level now
-    options: {
-      windowBuffer: 10,
-      //delayedProcessing: 10,  // Don't process messages until 60 seconds old
-      leaseTime: 300,
-      retryLimit: 3
-    }
-  })
-
-for (let i = 0; i < 10; i++) {
-await client.push({
-    items: [{
-        queue: 'htmls-delayed-02',
-        partition: 'html-02',  // Use 'Default' instead of 0
-        payload: { to: 'user-' + i + '@example.com' },
-    }]
-})
-}
-
-const stop = await client.consume({
-    queue: 'htmls-delayed-02',
-    partition: 'html-02',  // Use 'Default' instead of 0
-    handler: async (message) => {
-        console.log(message)
-    },
-    options: {
-        wait: true,
-        timeout: 30000,
-        batch: 5
-    }
-})

package/examples/smartchat.js

@@ -1,52 +0,0 @@
-// Create client
-import fs from 'fs';
-import { createQueenClient } from '../src/client/index.js';
-
-const client = createQueenClient({
-    baseUrl: 'http://localhost:6632'
-});
-
-const numberOfConsumers = 10
-
-async function producer () {
-    let count = 0;
-    while (true) {
-        const partition = count % 2;
-        console.log('Producing to partition:', partition);
-        const items = [];
-        for (let i = 0; i < 100; i++) {
-            items.push({ queue: 'htmls', partition: partition, payload: { to: 'user@example.com-' + count++ } });
-        }
-        await client.push({
-            items: items
-        })
-        await new Promise(resolve => setTimeout(resolve, 50));
-    }
-}
-
-async function consumer (i) {
-    const stop = client.consume({
-        queue: 'htmls',
-        consumerGroup: 'smartchat-' + i,
-        handler: async (message) => {
-          console.log(i, 'Processing:', message.data);
-          //fs.appendFileSync('consumed_items ' + message.partition + '.json', JSON.stringify(message.data) + '\n');
-        },
-        options: {
-            batch: 100,  // Process up to 10 messages at a time
-            wait: true,  // Wait for messages if queue is empty
-            timeout: 30000  // Timeout for long polling
-        }
-    });
-
-    return stop;
-}
-
-
-if (process.argv[2] === 'producer') {
-    producer(); 
-} else {
-    for (let i = 0; i < numberOfConsumers; i++) {
-        consumer(i);
-    }
-}

package/examples/test-cache-invalidation.js

@@ -1,119 +0,0 @@
-#!/usr/bin/env node
-/**
- * Example: Cache Invalidation with System Events
- * 
- * This example demonstrates how the system event propagation
- * ensures cache consistency across multiple server instances.
- */
-
-import { createQueenClient } from '../src/client/queenClient.js';
-
-// Simulate two different server instances
-const server1 = createQueenClient({ baseUrl: 'http://localhost:6632' });
-const server2 = createQueenClient({ baseUrl: 'http://localhost:6633' }); // Would be a different port in production
-
-async function demonstrateCacheInvalidation() {
-  console.log('📊 Demonstrating Cache Invalidation with System Events\n');
-  console.log('=' .repeat(60));
-  
-  const queueName = 'cache-test-queue';
-  
-  try {
-    // Step 1: Server 1 creates a queue
-    console.log('\n1️⃣ Server 1 creates a queue with initial configuration:');
-    await server1.configure({
-      queue: queueName,
-      options: {
-        ttl: 300,
-        retryLimit: 3,
-        priority: 5
-      }
-    });
-    console.log('   ✅ Queue created with TTL=300, retryLimit=3, priority=5');
-    
-    // Step 2: Both servers use the queue
-    console.log('\n2️⃣ Both servers push messages to the queue:');
-    
-    await server1.push({
-      queue: queueName,
-      messages: [{ id: 'msg-from-server1', payload: { source: 'server1' } }]
-    });
-    console.log('   ✅ Server 1 pushed a message (uses cached config)');
-    
-    // In a real multi-server setup, server2 would have its own cache
-    // For this demo, we're using the same server but the principle applies
-    await server2.push({
-      queue: queueName,
-      messages: [{ id: 'msg-from-server2', payload: { source: 'server2' } }]
-    });
-    console.log('   ✅ Server 2 pushed a message (fetches and caches config)');
-    
-    // Step 3: Server 1 updates the queue configuration
-    console.log('\n3️⃣ Server 1 updates queue configuration:');
-    await server1.configure({
-      queue: queueName,
-      options: {
-        ttl: 600,      // Changed from 300
-        retryLimit: 5, // Changed from 3
-        priority: 10   // Changed from 5
-      }
-    });
-    console.log('   ✅ Configuration updated: TTL=600, retryLimit=5, priority=10');
-    console.log('   📨 System event emitted to propagate changes');
-    
-    // Step 4: Wait a moment for event propagation
-    console.log('\n4️⃣ Waiting for system event propagation...');
-    await new Promise(resolve => setTimeout(resolve, 100));
-    
-    // Step 5: Both servers use the queue again
-    console.log('\n5️⃣ Both servers push messages again:');
-    
-    await server1.push({
-      queue: queueName,
-      messages: [{ id: 'msg2-from-server1', payload: { after: 'update' } }]
-    });
-    console.log('   ✅ Server 1 uses new config (immediate local update)');
-    
-    await server2.push({
-      queue: queueName,
-      messages: [{ id: 'msg2-from-server2', payload: { after: 'update' } }]
-    });
-    console.log('   ✅ Server 2 uses new config (cache invalidated by event)');
-    
-    // Step 6: Verify the queue stats
-    console.log('\n6️⃣ Verifying queue statistics:');
-    const stats = await server1.getQueueStats(queueName);
-    console.log(`   📊 Total messages: ${stats.total}`);
-    console.log(`   📊 Pending: ${stats.pending}`);
-    
-    // Step 7: Check system events queue
-    console.log('\n7️⃣ Checking system events queue:');
-    try {
-      const systemStats = await server1.getQueueStats('__system_events__');
-      console.log(`   📊 System events processed: ${systemStats.completed || 0}`);
-      console.log(`   📊 System events pending: ${systemStats.pending || 0}`);
-    } catch (error) {
-      console.log('   ℹ️ System queue may not have stats if events were already consumed');
-    }
-    
-    console.log('\n' + '=' .repeat(60));
-    console.log('✨ Cache invalidation demonstration completed!');
-    console.log('\n💡 Key Points:');
-    console.log('   • Configuration changes trigger system events');
-    console.log('   • Events are propagated to all server instances');
-    console.log('   • Each server invalidates its cache upon receiving events');
-    console.log('   • This ensures consistency across the cluster');
-    
-  } catch (error) {
-    console.error('❌ Error:', error.message);
-    process.exit(1);
-  }
-}
-
-// Run the demonstration
-demonstrateCacheInvalidation().then(() => {
-  process.exit(0);
-}).catch(error => {
-  console.error('Fatal error:', error);
-  process.exit(1);
-});