queen-mq 0.1.0

package/examples/test-cache-multi-server.js

@@ -0,0 +1,245 @@
+#!/usr/bin/env node
+
+/**
+ * Cache Testing with Multiple Servers
+ * 
+ * This script helps test if cache is causing issues when using multiple servers.
+ * It sends requests alternately to different servers to check cache consistency.
+ * 
+ * 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/test-cache-multi-server.js
+ */
+
+import { createQueenClient, LoadBalancingStrategy } from '../src/client/index.js';
+
+const servers = [
+  'http://localhost:6632',
+  'http://localhost:6633'
+];
+
+const TEST_QUEUE = 'cache-test';
+const TEST_NAMESPACE = 'cache-verification';
+
+// Helper to log with server info
+const log = (message, server = null) => {
+  const timestamp = new Date().toISOString().split('T')[1].slice(0, -1);
+  const serverInfo = server ? ` [${server}]` : '';
+  console.log(`${timestamp}${serverInfo} | ${message}`);
+};
+
+async function testCacheConsistency() {
+  console.log('=' .repeat(80));
+  console.log('Testing Cache Consistency Across Multiple Servers');
+  console.log('=' .repeat(80));
+  
+  // Create client with ROUND_ROBIN to alternate between servers
+  const roundRobinClient = createQueenClient({
+    baseUrls: servers,
+    loadBalancingStrategy: LoadBalancingStrategy.ROUND_ROBIN,
+    enableFailover: false // Disable failover to see actual server responses
+  });
+  
+  // Create client with SESSION to stick to one server
+  const sessionClient = createQueenClient({
+    baseUrls: servers,
+    loadBalancingStrategy: LoadBalancingStrategy.SESSION,
+    enableFailover: false
+  });
+  
+  try {
+    // Step 1: Configure queue on both servers via round-robin
+    log('Step 1: Configuring queue on both servers...');
+    
+    for (let i = 0; i < servers.length; i++) {
+      await roundRobinClient.configure({
+        queue: TEST_QUEUE,
+        namespace: TEST_NAMESPACE,
+        task: 'cache-test',
+        options: {
+          maxRetries: 3,
+          retryDelay: 1000,
+          priority: 5
+        }
+      });
+      const stats = roundRobinClient.getLoadBalancerStats();
+      log(`Configuration sent to server ${i + 1}`, servers[i]);
+    }
+    
+    // Step 2: Push messages alternating between servers
+    log('\nStep 2: Pushing messages to alternate servers...');
+    
+    for (let i = 1; i <= 6; i++) {
+      const result = await roundRobinClient.push({
+        items: [{
+          queue: TEST_QUEUE,
+          partition: 'Default',
+          payload: { 
+            messageId: i,
+            server: `push-${i % 2 === 0 ? 2 : 1}`,
+            timestamp: Date.now()
+          }
+        }]
+      });
+      
+      const stats = roundRobinClient.getLoadBalancerStats();
+      log(`Message ${i} pushed`, servers[(i - 1) % servers.length]);
+    }
+    
+    // Step 3: Check queue stats from both servers
+    log('\nStep 3: Checking queue stats from each server...');
+    
+    for (let i = 0; i < servers.length; i++) {
+      try {
+        const analytics = await roundRobinClient.analytics.queue(TEST_QUEUE);
+        log(`Queue stats from server ${i + 1}: ${JSON.stringify(analytics)}`, servers[i]);
+      } catch (error) {
+        log(`Failed to get stats from server ${i + 1}: ${error.message}`, servers[i]);
+      }
+    }
+    
+    // Step 4: Pop messages from different servers
+    log('\nStep 4: Popping messages from different servers...');
+    
+    // Pop from server 1 (using session client for consistency)
+    const sessionClient1 = createQueenClient({
+      baseUrl: servers[0],
+      enableFailover: false
+    });
+    
+    const pop1 = await sessionClient1.pop({
+      queue: TEST_QUEUE,
+      batch: 3,
+      wait: false
+    });
+    
+    log(`Server 1 returned ${pop1.messages?.length || 0} messages`, servers[0]);
+    if (pop1.messages && pop1.messages.length > 0) {
+      for (const msg of pop1.messages) {
+        log(`  - Message: ${JSON.stringify(msg.payload)}`, servers[0]);
+        await sessionClient1.ack(msg.transactionId, 'completed');
+      }
+    }
+    
+    // Pop from server 2
+    const sessionClient2 = createQueenClient({
+      baseUrl: servers[1],
+      enableFailover: false
+    });
+    
+    const pop2 = await sessionClient2.pop({
+      queue: TEST_QUEUE,
+      batch: 3,
+      wait: false
+    });
+    
+    log(`Server 2 returned ${pop2.messages?.length || 0} messages`, servers[1]);
+    if (pop2.messages && pop2.messages.length > 0) {
+      for (const msg of pop2.messages) {
+        log(`  - Message: ${JSON.stringify(msg.payload)}`, servers[1]);
+        await sessionClient2.ack(msg.transactionId, 'completed');
+      }
+    }
+    
+    // Step 5: Test resource cache consistency
+    log('\nStep 5: Testing resource cache consistency...');
+    
+    // Update configuration on server 1
+    const updateClient1 = createQueenClient({
+      baseUrl: servers[0],
+      enableFailover: false
+    });
+    
+    await updateClient1.configure({
+      queue: TEST_QUEUE,
+      namespace: TEST_NAMESPACE,
+      task: 'cache-test-updated',
+      options: {
+        maxRetries: 5, // Changed from 3
+        retryDelay: 2000, // Changed from 1000
+        priority: 10 // Changed from 5
+      }
+    });
+    
+    log('Configuration updated on server 1', servers[0]);
+    
+    // Wait a moment for potential cache propagation
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    
+    // Check if server 2 sees the update
+    log('Checking if configuration changes are visible on both servers...');
+    
+    // Push a message to server 2 and see if it uses new or old config
+    const testClient2 = createQueenClient({
+      baseUrl: servers[1],
+      enableFailover: false
+    });
+    
+    await testClient2.push({
+      items: [{
+        queue: TEST_QUEUE,
+        partition: 'CacheTest',
+        payload: { 
+          test: 'cache-verification',
+          expectedConfig: 'Should use database config, not cached'
+        }
+      }]
+    });
+    
+    log('Test message pushed to server 2', servers[1]);
+    
+    // Pop and check the message properties
+    const verifyPop = await testClient2.pop({
+      queue: TEST_QUEUE,
+      partition: 'CacheTest',
+      wait: false
+    });
+    
+    if (verifyPop.messages && verifyPop.messages.length > 0) {
+      const msg = verifyPop.messages[0];
+      log(`Message from server 2: priority=${msg.priority}, retryCount=${msg.retryCount}`, servers[1]);
+      
+      // Check queue configuration directly to verify cache consistency
+      const queueStats = await testClient2.analytics.queue(TEST_QUEUE);
+      log(`Queue config from server 2: ${JSON.stringify(queueStats)}`, servers[1]);
+      
+      // Priority is included in the message and should reflect the updated value
+      if (msg.priority === 10) {
+        log('✅ Cache consistency verified! Server 2 sees updated priority configuration', servers[1]);
+      } else {
+        log(`⚠️  Potential cache issue: Server 2 may be using cached configuration (priority=${msg.priority} instead of 10)`, servers[1]);
+      }
+      
+      await testClient2.ack(msg.transactionId, 'completed');
+    }
+    
+    // Step 6: Clean up
+    log('\nStep 6: Cleaning up test data...');
+    
+    // Clear the queue on both servers
+    await roundRobinClient.queues.clear(TEST_QUEUE);
+    log('Test queue cleared');
+    
+    console.log('\n' + '=' .repeat(80));
+    log('✅ Cache consistency test completed!');
+    console.log('=' .repeat(80));
+    
+    // Print summary
+    console.log('\nSummary:');
+    console.log('- If both servers returned the same messages, they share the same database');
+    console.log('- If configuration changes were visible on both servers, cache is properly invalidated');
+    console.log('- If you see cache issues, check the resourceCache implementation in queueManagerOptimized.js');
+    
+  } catch (error) {
+    log(`❌ Test failed: ${error.message}`);
+    console.error(error);
+    process.exit(1);
+  }
+}
+
+// Run the test
+testCacheConsistency().catch(console.error);

package/examples/test-minimal-client.js

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+
+/**
+ * Test the minimalist Queen client interface
+ */
+
+import { Queen } from '../src/client/client.js';
+
+async function main() {
+  console.log('🧪 Testing Minimalist Queen Client\n');
+  
+  // Create client instance
+  const client = new Queen({
+    baseUrls: ['http://localhost:6632'],
+    timeout: 30000,
+    retryAttempts: 3,
+    retryDelay: 1000
+  });
+  
+  const testQueue = 'test-minimal-' + Date.now();
+  
+  try {
+    // 1. Configure queue
+    console.log('1️⃣ Configuring queue...');
+    await client.queue(testQueue, {
+      leaseTime: 300,
+      retryLimit: 3,
+      retryDelay: 1000
+    });
+    console.log('✅ Queue configured:', testQueue);
+    
+    // 2. Push single message
+    console.log('\n2️⃣ Pushing single message...');
+    await client.push(testQueue, {
+      id: 1,
+      message: 'Hello, Queen!',
+      timestamp: new Date().toISOString()
+    });
+    console.log('✅ Single message pushed');
+    
+    // 3. Push batch of messages
+    console.log('\n3️⃣ Pushing batch of messages...');
+    const batch = [
+      { id: 2, message: 'Message 2' },
+      { id: 3, message: 'Message 3' },
+      { id: 4, message: 'Message 4' }
+    ];
+    await client.push(testQueue, batch);
+    console.log('✅ Batch of 3 messages pushed');
+    
+    // 4. Push to specific partition
+    console.log('\n4️⃣ Pushing to urgent partition...');
+    await client.push(`${testQueue}/urgent`, {
+      id: 5,
+      message: 'Urgent message!',
+      priority: 'high'
+    });
+    console.log('✅ Message pushed to urgent partition');
+    
+    // 5. Take messages with limit
+    console.log('\n5️⃣ Taking 3 messages...');
+    let count = 0;
+    for await (const message of client.take(testQueue, { limit: 3 })) {
+      count++;
+      console.log(`  📩 Message ${count}:`, message.data);
+      await client.ack(message);
+    }
+    console.log('✅ Took and acknowledged 3 messages');
+    
+    // 6. Take from specific partition
+    console.log('\n6️⃣ Taking from urgent partition...');
+    for await (const message of client.take(`${testQueue}/urgent`, { limit: 1 })) {
+      console.log('  🚨 Urgent message:', message.data);
+      await client.ack(message, true);
+    }
+    console.log('✅ Processed urgent message');
+    
+    // 7. Test failure acknowledgment
+    console.log('\n7️⃣ Testing failure acknowledgment...');
+    await client.push(testQueue, { id: 6, message: 'Will fail' });
+    
+    for await (const message of client.take(testQueue, { limit: 1 })) {
+      console.log('  ❌ Simulating failure for:', message.data);
+      await client.ack(message, false, { error: 'Simulated error' });
+    }
+    console.log('✅ Failed acknowledgment sent');
+    
+    // 8. Test consumer groups (if needed)
+    console.log('\n8️⃣ Testing consumer groups...');
+    await client.push(testQueue, { id: 7, message: 'For consumer group' });
+    
+    for await (const message of client.take(`${testQueue}@test-group`, { limit: 1 })) {
+      console.log('  👥 Message via consumer group:', message.data);
+      await client.ack(message, true, { group: 'test-group' });
+    }
+    console.log('✅ Consumer group test complete');
+    
+    console.log('\n🎉 All tests passed!');
+    
+  } catch (error) {
+    console.error('\n❌ Test failed:', error.message);
+    process.exit(1);
+  } finally {
+    await client.close();
+  }
+}
+
+// Run tests
+main().catch(error => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});

package/examples/test-queue-creation-policy.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+
+/**
+ * Test script to verify the new queue creation policy:
+ * - Queues must be created via configure endpoint
+ * - Push to non-existent queue should fail
+ * - Partitions can still be created on-demand
+ */
+
+import { createQueenClient } from '../src/client/index.js';
+
+const TEST_QUEUE = 'test-creation-policy';
+const NON_EXISTENT_QUEUE = 'queue-that-does-not-exist';
+
+// Helper to log with timestamp
+const log = (message, type = 'info') => {
+  const timestamp = new Date().toISOString().split('T')[1].slice(0, -1);
+  const prefix = type === 'error' ? '❌' : type === 'success' ? '✅' : 'ℹ️';
+  console.log(`${timestamp} | ${prefix} ${message}`);
+};
+
+async function runTests() {
+  console.log('=' .repeat(80));
+  console.log('Testing Queue Creation Policy');
+  console.log('=' .repeat(80));
+  
+  const client = createQueenClient({
+    baseUrl: 'http://localhost:6632'
+  });
+  
+  try {
+    // Test 1: Push to non-existent queue should fail
+    log('\nTest 1: Pushing to non-existent queue (should fail)...');
+    try {
+      await client.push({
+        items: [{
+          queue: NON_EXISTENT_QUEUE,
+          partition: 'Default',
+          payload: { test: 'should fail' }
+        }]
+      });
+      log('Push succeeded unexpectedly!', 'error');
+      process.exit(1);
+    } catch (error) {
+      if (error.message.includes('does not exist')) {
+        log(`Push failed as expected: ${error.message}`, 'success');
+      } else {
+        log(`Push failed with unexpected error: ${error.message}`, 'error');
+        throw error;
+      }
+    }
+    
+    // Test 2: Create queue via configure
+    log('\nTest 2: Creating queue via configure endpoint...');
+    const configResult = await client.configure({
+      queue: TEST_QUEUE,
+      namespace: 'test',
+      task: 'creation-policy',
+      options: {
+        retryLimit: 3,
+        priority: 5
+      }
+    });
+    log(`Queue configured: ${JSON.stringify(configResult)}`, 'success');
+    
+    // Test 3: Push to configured queue should succeed
+    log('\nTest 3: Pushing to configured queue (should succeed)...');
+    const pushResult1 = await client.push({
+      items: [{
+        queue: TEST_QUEUE,
+        partition: 'Default',
+        payload: { test: 'message 1' }
+      }]
+    });
+    log('Push to Default partition succeeded', 'success');
+    
+    // Test 4: Push to new partition (should create partition on-demand)
+    log('\nTest 4: Pushing to new partition (should create on-demand)...');
+    const pushResult2 = await client.push({
+      items: [{
+        queue: TEST_QUEUE,
+        partition: 'NewPartition',
+        payload: { test: 'message 2' }
+      }]
+    });
+    log('Push to NewPartition succeeded (partition created on-demand)', 'success');
+    
+    // Test 5: Verify messages can be popped
+    log('\nTest 5: Verifying messages can be popped...');
+    const popResult = await client.pop({
+      queue: TEST_QUEUE,
+      batch: 10,
+      wait: false
+    });
+    
+    if (popResult.messages && popResult.messages.length === 2) {
+      log(`Successfully retrieved ${popResult.messages.length} messages`, 'success');
+      
+      // Check partitions
+      const partitions = new Set(popResult.messages.map(m => m.partition));
+      if (partitions.has('Default') && partitions.has('NewPartition')) {
+        log('Both partitions (Default and NewPartition) confirmed', 'success');
+      }
+      
+      // Acknowledge messages
+      for (const msg of popResult.messages) {
+        await client.ack(msg.transactionId, 'completed');
+      }
+      log('Messages acknowledged', 'success');
+    } else {
+      log(`Expected 2 messages, got ${popResult.messages?.length || 0}`, 'error');
+    }
+    
+    // Test 6: Clean up
+    log('\nTest 6: Cleaning up...');
+    await client.queues.clear(TEST_QUEUE);
+    log('Test queue cleared', 'success');
+    
+    console.log('\n' + '=' .repeat(80));
+    log('All tests passed! Queue creation policy working correctly', 'success');
+    console.log('=' .repeat(80));
+    
+    console.log('\nSummary:');
+    console.log('✅ Queues must be created via configure endpoint');
+    console.log('✅ Push to non-existent queue fails with clear error');
+    console.log('✅ Partitions can still be created on-demand');
+    console.log('✅ No implicit queue creation during push operations');
+    
+  } catch (error) {
+    log(`Test failed: ${error.message}`, 'error');
+    console.error(error);
+    process.exit(1);
+  }
+}
+
+// Run the tests
+runTests().catch(console.error);

package/init-db.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import { createPool, initDatabase } from './src/database/connection.js';
+
+const init = async () => {
+  console.log('Initializing Queen database schema...');
+  
+  const pool = createPool();
+  
+  try {
+    await initDatabase(pool);
+    console.log('✅ Database schema initialized successfully');
+  } catch (error) {
+    console.error('❌ Failed to initialize database:', error.message);
+    process.exit(1);
+  } finally {
+    await pool.end();
+  }
+};
+
+init();

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "queen-mq",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "High-performance message queue backed by PostgreSQL",
+  "main": "src/client/index.js",
+
+  "scripts": {
+    "start": "node src/server.js",
+    "test:produce": "node test.js produce",
+    "test:consume": "node test.js consume",
+    "test": "node src/test/test.js",
+    "test:core": "node src/test/core-features-test.js",
+    "test:comprehensive": "node src/test/comprehensive-test.js",
+    "test:edge": "node src/test/comprehensive-edge-cases-test.js",
+    "test:advanced": "node src/test/advanced-scenarios-test.js",
+    "test:all": "npm run test && npm run test:edge && npm run test:advanced",
+    "test:quick": "npm run test:core",
+    "test:lease": "node src/test/test-lease-expiration.js",
+    "test:lease:simple": "node test-lease-simple.js",
+    "test:client": "node test-client.js",
+    "test:simple": "node test-simple.js",
+    "init": "node init-db.js"
+  },
+  "dependencies": {
+    "pg": "^8.13.3",
+    "uuid": "^13.0.0",
+    "uWebSockets.js": "github:uNetworking/uWebSockets.js#v20.52.0",
+    "ws": "^8.18.3"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "author": "",
+  "license": "ISC"
+}