jsgui3-server 0.0.138 → 0.0.140

package/examples/json/simple-api/server.js

@@ -0,0 +1,91 @@
+// Simple JSON API Example
+// Demonstrates basic JSON API functionality with minimal code
+
+const Server = require('../../../server');
+
+// Simple in-memory data store
+let messages = [
+  { id: 1, text: 'Hello, World!', author: 'System', timestamp: new Date() },
+  { id: 2, text: 'Welcome to JSGUI3 Server JSON API', author: 'API', timestamp: new Date() }
+];
+
+let nextId = 3;
+
+Server.serve({
+  // No UI control - pure JSON API server
+  // ctrl: undefined,
+
+  api: {
+    // GET /api/messages - Get all messages
+    'messages': () => ({
+      messages: messages,
+      count: messages.length
+    }),
+
+    // GET /api/status - Server status
+    'status': () => ({
+      status: 'running',
+      timestamp: new Date(),
+      version: '1.0.0',
+      uptime: process.uptime()
+    }),
+
+    // POST /api/add-message - Add a new message
+    'add-message': (data) => {
+      if (!data.text || typeof data.text !== 'string') {
+        throw new Error('Message text is required');
+      }
+
+      if (data.text.length > 500) {
+        throw new Error('Message text must be 500 characters or less');
+      }
+
+      const newMessage = {
+        id: nextId++,
+        text: data.text.trim(),
+        author: data.author || 'Anonymous',
+        timestamp: new Date()
+      };
+
+      messages.push(newMessage);
+
+      return {
+        success: true,
+        message: newMessage
+      };
+    },
+
+    // POST /api/clear-messages - Clear all messages
+    'clear-messages': () => {
+      const count = messages.length;
+      messages = [];
+      nextId = 1;
+
+      return {
+        success: true,
+        clearedCount: count,
+        message: `Cleared ${count} messages`
+      };
+    }
+  },
+
+  port: 3002
+}).then(server => {
+  console.log('🚀 Simple JSON API Server started!');
+  console.log(`📡 Running at: http://localhost:${server.port}`);
+  console.log('\n📋 Available endpoints:');
+  console.log('  GET  /api/messages      - Get all messages');
+  console.log('  GET  /api/status        - Server status');
+  console.log('  POST /api/add-message   - Add new message');
+  console.log('  POST /api/clear-messages - Clear all messages');
+  console.log('\n🧪 Test with:');
+  console.log('  curl http://localhost:3002/api/status');
+  console.log('  curl -X POST http://localhost:3002/api/add-message \\');
+  console.log('    -H "Content-Type: application/json" \\');
+  console.log('    -d \'{"text":"Hello from curl!","author":"Tester"}\'');
+
+}).catch(err => {
+  console.error('❌ Failed to start server:', err.message);
+  console.error('❌ Full error:', err);
+  process.exit(1);
+});

package/examples/json/simple-api/test.js

@@ -0,0 +1,215 @@
+// Test file for the simple JSON API example
+// Runs the server and tests all endpoints
+
+const { spawn } = require('child_process');
+const http = require('http');
+
+async function testSimpleAPI() {
+  console.log('🧪 Testing Simple JSON API Example');
+  console.log('=====================================\n');
+
+  let serverProcess;
+
+  try {
+    // Start the server
+    console.log('🚀 Starting server...');
+    serverProcess = spawn('node', ['server.js'], {
+      cwd: __dirname,
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+
+    // Wait for server to start
+    await new Promise((resolve, reject) => {
+      let output = '';
+      const timeout = setTimeout(() => {
+        reject(new Error('Server startup timeout'));
+      }, 10000);
+
+      serverProcess.stdout.on('data', (data) => {
+        output += data.toString();
+        console.log('Server output:', data.toString().trim());
+        // Look for server started message indicating server is listening
+        if (output.includes('🚀 Simple JSON API Server started!')) {
+          clearTimeout(timeout);
+          console.log('✅ Server started successfully and is listening');
+          // Wait a moment for server to be fully ready
+          setTimeout(() => {
+            console.log('⏳ Waiting for server to be ready...');
+            setTimeout(resolve, 0); // Brief additional wait
+          }, 0);
+        }
+      });
+
+      serverProcess.stderr.on('data', (data) => {
+        console.error('Server error:', data.toString());
+      });
+
+      serverProcess.on('error', reject);
+    });
+
+    const baseUrl = 'http://localhost:3002';
+
+    // Test 1: GET /api/status
+    console.log('\n📋 Test 1: GET /api/status');
+    let statusResponse;
+    try {
+      statusResponse = await makeRequest('GET', '/api/status');
+      console.log('Response:', JSON.stringify(statusResponse, null, 2));
+    } catch (error) {
+      console.error('Request failed:', error.message);
+      console.error('Full error:', error);
+      throw error;
+    }
+
+    if (!statusResponse.status || statusResponse.status !== 'running') {
+      throw new Error('Status endpoint failed - expected status: "running"');
+    }
+    console.log('✅ Status test passed - server is running');
+
+    // Test 2: GET /api/messages
+    console.log('\n📋 Test 2: GET /api/messages');
+    const messagesResponse = await makeRequest('GET', '/api/messages');
+    console.log('Response:', JSON.stringify(messagesResponse, null, 2));
+
+    if (!messagesResponse.messages || !Array.isArray(messagesResponse.messages)) {
+      throw new Error('Messages endpoint failed - expected messages array');
+    }
+    console.log(`✅ Messages test passed - found ${messagesResponse.messages.length} initial messages`);
+
+    // Test 3: POST /api/add-message
+    console.log('\n📋 Test 3: POST /api/add-message');
+    const addMessageData = {
+      text: 'Test message from automated test',
+      author: 'Test Suite'
+    };
+    const addResponse = await makeRequest('POST', '/api/add-message', addMessageData);
+    console.log('Response:', JSON.stringify(addResponse, null, 2));
+
+    if (!addResponse.success || !addResponse.message) {
+      throw new Error('Add message endpoint failed - expected success response with message');
+    }
+    console.log('✅ Add message test passed - message added successfully');
+
+    // Test 4: Verify message was added
+    console.log('\n📋 Test 4: Verify message was added');
+    const messagesAfterAdd = await makeRequest('GET', '/api/messages');
+    const hasNewMessage = messagesAfterAdd.messages.some(msg =>
+      msg.text === 'Test message from automated test'
+    );
+
+    if (!hasNewMessage) {
+      throw new Error('Message was not added correctly - test message not found in messages list');
+    }
+    console.log('✅ Message verification test passed - test message found in list');
+
+    // Test 5: POST /api/clear-messages
+    console.log('\n📋 Test 5: POST /api/clear-messages');
+    const clearResponse = await makeRequest('POST', '/api/clear-messages');
+    console.log('Response:', JSON.stringify(clearResponse, null, 2));
+
+    if (!clearResponse.success) {
+      throw new Error('Clear messages endpoint failed - expected success response');
+    }
+    console.log('✅ Clear messages test passed - messages cleared successfully');
+
+    // Test 6: Verify messages were cleared
+    console.log('\n📋 Test 6: Verify messages were cleared');
+    const messagesAfterClear = await makeRequest('GET', '/api/messages');
+
+    if (messagesAfterClear.count !== 0) {
+      throw new Error('Messages were not cleared correctly - expected count to be 0');
+    }
+    console.log('✅ Message clearing verification test passed - all messages cleared');
+
+    // Test 7: Error handling
+    console.log('\n📋 Test 7: Error handling test');
+    try {
+      const errorResponse = await makeRequest('POST', '/api/add-message', { text: '' });
+      console.log('Error response:', JSON.stringify(errorResponse, null, 2));
+      if (!errorResponse.error || !errorResponse.error.includes('Message text is required')) {
+        throw new Error('Error handling test failed - expected error response with "Message text is required"');
+      }
+      console.log('✅ Error handling test passed - validation working correctly');
+    } catch (error) {
+      throw new Error('Error handling test failed: ' + error.message);
+    }
+
+    console.log('\n🎉 All tests passed! Simple JSON API is working correctly.');
+    console.log('\n📊 Test Summary:');
+    console.log('  ✅ Server startup');
+    console.log('  ✅ GET /api/status');
+    console.log('  ✅ GET /api/messages');
+    console.log('  ✅ POST /api/add-message');
+    console.log('  ✅ Message persistence');
+    console.log('  ✅ POST /api/clear-messages');
+    console.log('  ✅ Message clearing');
+    console.log('  ✅ Error handling');
+
+  } catch (error) {
+    console.error('\n❌ Test failed:', error.message);
+    process.exit(1);
+  } finally {
+    // Clean up server process
+    if (serverProcess) {
+      console.log('\n🧹 Shutting down server...');
+      serverProcess.kill('SIGTERM');
+
+      // Wait a bit for graceful shutdown
+      setTimeout(() => {
+        if (!serverProcess.killed) {
+          serverProcess.kill('SIGKILL');
+        }
+        console.log('✅ Server shut down');
+      }, 2000);
+    }
+  }
+}
+
+// Helper function to make HTTP requests
+function makeRequest(method, path, data = null) {
+  return new Promise((resolve, reject) => {
+    const options = {
+      hostname: 'localhost',
+      port: 3002,
+      path: path,
+      method: method,
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    };
+
+    const req = http.request(options, (res) => {
+      let body = '';
+
+      res.on('data', (chunk) => {
+        body += chunk;
+      });
+
+      res.on('end', () => {
+        try {
+          const response = JSON.parse(body);
+          resolve(response);
+        } catch (error) {
+          reject(new Error(`Failed to parse response: ${body}`));
+        }
+      });
+    });
+
+    req.on('error', (error) => {
+      reject(error);
+    });
+
+    if (data) {
+      req.write(JSON.stringify(data));
+    }
+
+    req.end();
+  });
+}
+
+// Run the tests
+if (require.main === module) {
+  testSimpleAPI().catch(console.error);
+}
+
+module.exports = { testSimpleAPI };

package/http/responders/static/Static_Route_HTTP_Responder.js

@@ -84,8 +84,7 @@ class Static_Route_HTTP_Responder extends HTTP_Responder {
         // Then write the (hopefully compressed) response bodies...
 
         if (supported_encodings.br === true) {
-            
-            res.write(response_buffers.br);
+
             res.write(response_buffers.br);
         } else if (supported_encodings.gzip === true) {
             //console.log('should write gzipped buffer...');

package/package.json

@@ -7,19 +7,19 @@
     "@babel/generator": "^7.28.5",
     "@babel/parser": "^7.28.5",
     "cookies": "^0.9.1",
-    "esbuild": "^0.25.11",
-    "fnl": "^0.0.36",
-    "fnlfs": "^0.0.33",
+    "esbuild": "^0.25.12",
+    "fnl": "^0.0.37",
+    "fnlfs": "^0.0.34",
     "jsgui3-client": "^0.0.120",
-    "jsgui3-html": "^0.0.168",
+    "jsgui3-html": "^0.0.170",
     "jsgui3-webpage": "^0.0.8",
     "jsgui3-website": "^0.0.8",
-    "lang-tools": "^0.0.39",
+    "lang-tools": "^0.0.41",
     "mocha": "^11.7.4",
     "multiparty": "^4.2.3",
     "ncp": "^2.0.0",
     "obext": "^0.0.31",
-    "rimraf": "^6.0.1",
+    "rimraf": "^6.1.0",
     "stream-to-array": "^2.3.0",
     "url-parse": "^1.5.10"
   },
@@ -39,10 +39,21 @@
     "type": "git",
     "url": "https://github.com/metabench/jsgui3-server.git"
   },
-  "version": "0.0.138",
+  "version": "0.0.140",
   "scripts": {
     "cli": "node cli.js",
     "serve": "node cli.js serve",
-    "test": "mocha tests/**/*.test.js"
+    "test": "node tests/test-runner.js",
+    "test:mocha": "mocha tests/**/*.test.js",
+    "test:bundlers": "node tests/test-runner.js --test=bundlers.test.js",
+    "test:assigners": "node tests/test-runner.js --test=assigners.test.js",
+    "test:publishers": "node tests/test-runner.js --test=publishers.test.js",
+    "test:config": "node tests/test-runner.js --test=configuration-validation.test.js",
+    "test:e2e": "node tests/test-runner.js --test=end-to-end.test.js",
+    "test:content": "node tests/test-runner.js --test=content-analysis.test.js",
+    "test:performance": "node tests/test-runner.js --test=performance.test.js",
+    "test:errors": "node tests/test-runner.js --test=error-handling.test.js",
+    "test:debug": "node tests/test-runner.js --debug",
+    "test:verbose": "node tests/test-runner.js --verbose"
   }
 }

package/publishers/helpers/assigners/static-compressed-response-buffers/Single_Control_Webpage_Server_Static_Compressed_Response_Buffers_Assigner.js

@@ -43,6 +43,16 @@ class Single_Control_Webpage_Server_Static_Compressed_Response_Buffers_Assigner
 
     constructor(spec = {}) {
         super(spec);
+
+        // Store compression configuration
+        this.compression_config = spec.compression || {};
+        this.compression_stats = {
+            total_items: 0,
+            gzip_compressed: 0,
+            brotli_compressed: 0,
+            gzip_savings: 0,
+            brotli_savings: 0
+        };
     }
 
     // assign to bundle....
@@ -54,6 +64,18 @@ class Single_Control_Webpage_Server_Static_Compressed_Response_Buffers_Assigner
     // These assign functions should (all probably) be async
 
     async assign(arr_bundled_items) {
+        // Get compression configuration with defaults
+        const enabled = this.compression_config.enabled !== false; // Default: true
+        const algorithms = this.compression_config.algorithms || ['gzip', 'br'];
+        const gzipLevel = this.compression_config.gzip?.level || 6;
+        const brotliQuality = this.compression_config.brotli?.quality || 6;
+        const threshold = this.compression_config.threshold || 1024;
+
+        if (!enabled) {
+            console.log('Compression disabled, skipping compression assignment');
+            return;
+        }
+
         // go through them....
 
         // Maybe check that the correct items are in the bundle.
@@ -84,20 +106,42 @@ class Single_Control_Webpage_Server_Static_Compressed_Response_Buffers_Assigner
                 // // response_buffers.identity I think....
 
                 if (item.text) {
+                    const originalSize = item.response_buffers.identity.length;
+                    this.compression_stats.total_items++;
+
+                    // Skip compression if below threshold
+                    if (originalSize < threshold) {
+                        console.log(`Skipping compression for ${item.type} (${originalSize} bytes < ${threshold} threshold)`);
+                        continue;
+                    }
 
                     // Async compression definitely seems much better here.
-                    const buf_gzipped = await gzip_compress(item.response_buffers.identity);
-                    item.response_buffers.gzip = buf_gzipped;
-
-                    const buf_br = await br_compress(item.response_buffers.identity, {
-                        params: {
-                            //[zlib.constants.BROTLI_PARAM_MODE]: zlib.constants.BROTLI_MODE_TEXT,
-                            [zlib.constants.BROTLI_PARAM_QUALITY]: 10,
-                            [zlib.constants.BROTLI_PARAM_SIZE_HINT]: item.response_buffers.identity.length,
-                          }
-                    });
-
-                    item.response_buffers.br = buf_br;
+                    if (algorithms.includes('gzip')) {
+                        const buf_gzipped = await gzip_compress(item.response_buffers.identity, { level: gzipLevel });
+                        item.response_buffers.gzip = buf_gzipped;
+                        const compressedSize = buf_gzipped.length;
+                        const savings = originalSize - compressedSize;
+                        this.compression_stats.gzip_compressed++;
+                        this.compression_stats.gzip_savings += savings;
+                        console.log(`Gzip compressed ${item.type}: ${originalSize} → ${compressedSize} bytes (${Math.round(savings/originalSize*100)}% savings)`);
+                    }
+
+                    if (algorithms.includes('br')) {
+                        const buf_br = await br_compress(item.response_buffers.identity, {
+                            params: {
+                                //[zlib.constants.BROTLI_PARAM_MODE]: zlib.constants.BROTLI_MODE_TEXT,
+                                [zlib.constants.BROTLI_PARAM_QUALITY]: brotliQuality,
+                                [zlib.constants.BROTLI_PARAM_SIZE_HINT]: item.response_buffers.identity.length,
+                              }
+                        });
+
+                        item.response_buffers.br = buf_br;
+                        const compressedSize = buf_br.length;
+                        const savings = originalSize - compressedSize;
+                        this.compression_stats.brotli_compressed++;
+                        this.compression_stats.brotli_savings += savings;
+                        console.log(`Brotli compressed ${item.type}: ${originalSize} → ${compressedSize} bytes (${Math.round(savings/originalSize*100)}% savings)`);
+                    }
                 } else {
 
                 }
@@ -105,6 +149,15 @@ class Single_Control_Webpage_Server_Static_Compressed_Response_Buffers_Assigner
                 //throw 'stop';
             }
 
+            // Log compression statistics
+            console.log('Compression Statistics:', {
+                total_items: this.compression_stats.total_items,
+                gzip_compressed: this.compression_stats.gzip_compressed,
+                brotli_compressed: this.compression_stats.brotli_compressed,
+                total_gzip_savings: `${Math.round(this.compression_stats.gzip_savings/1024)}KB`,
+                total_brotli_savings: `${Math.round(this.compression_stats.brotli_savings/1024)}KB`
+            });
+
         } else {
             console.trace();
             throw 'stop';

package/publishers/helpers/preparers/static/bundle/Static_Routes_Responses_Webpage_Bundle_Preparer.js

@@ -17,12 +17,17 @@ class Static_Routes_Responses_Webpage_Bundle_Preparer {
 
         //if (spec.debug !== undefined) this.debug = spec.debug;
 
+        // Store bundler configuration to pass to compression assigner
+        this.bundler_config = spec.bundler_config || {};
+
         this.routes_assigner = new Single_Control_Webpage_Server_Static_Routes_Assigner();
 
         // And the uncompressed response buffer(s) assigner....?
 
         this.uncompressed_response_buffers_assigner = new Single_Control_Webpage_Server_Static_Uncompressed_Response_Buffers_Assigner();
-        this.compressed_response_buffers_assigner = new Single_Control_Webpage_Server_Static_Compressed_Response_Buffers_Assigner();
+        this.compressed_response_buffers_assigner = new Single_Control_Webpage_Server_Static_Compressed_Response_Buffers_Assigner({
+            compression: this.bundler_config.compression
+        });
         this.headers_assigner = new Single_Control_Webpage_Server_Static_Headers_Assigner();
 
 

package/publishers/http-function-publisher.js

@@ -110,7 +110,12 @@ class Function_Publisher extends HTTP_Publisher {
                 } else {
 
                     if (content_type === 'application/json') {
-                        obj_input = JSON.parse(buf_input.toString());
+                        const inputStr = buf_input.toString();
+                        if (inputStr.trim() === '') {
+                            obj_input = null;
+                        } else {
+                            obj_input = JSON.parse(inputStr);
+                        }
                     } else {
                         console.trace();
                         throw 'NYI';
@@ -141,57 +146,73 @@ class Function_Publisher extends HTTP_Publisher {
                 // And the function to call may be async.
                 //  Can test to see if we get a promise (or observable) back from it.
 
-                const fn_res = fn(obj_input);
-                const tfr = tf(fn_res);
-                //console.log('fn_res', fn_res);
-                
-                //
+                try {
+                    const fn_res = fn(obj_input);
+                    const tfr = tf(fn_res);
+                    //console.log('fn_res', fn_res);
 
-                if (tfr === 'p') {
-                    // promise
-                    console.log('need to await promise resolution');
+                    //
 
-                    fn_res.then(call_res => {
-                        console.log('fn_res then happened, call_res', call_res);
-                        output_all(call_res);
+                    if (tfr === 'p') {
+                        // promise
+                        console.log('need to await promise resolution');
 
-                    }, err => {
+                        fn_res.then(call_res => {
+                            console.log('fn_res then happened, call_res', call_res);
+                            output_all(call_res);
 
-                    });
+                        }, err => {
+                            console.error('Function execution error:', err);
+                            if (!res.headersSent) {
+                                res.writeHead(500, {
+                                    'Content-Type': 'application/json'
+                                });
+                                res.end(JSON.stringify({ error: err.message }));
+                            }
+                        });
 
 
-                } else if (tfr === 's') {
-                    // Just write it as a string for the moment I think?
-                    //   Or always encode as JSON?
+                    } else if (tfr === 's') {
+                        // Just write it as a string for the moment I think?
+                        //   Or always encode as JSON?
 
-                    // text/plain;charset=UTF-8
+                        // text/plain;charset=UTF-8
 
-                    res.writeHead(200, {
-                        'Content-Type': 'text/plain;charset=UTF-8'//,
-                        //'Transfer-Encoding': 'chunked',
-                        //'Trailer': 'Content-MD5'
-                    });
-                    res.end(fn_res);
+                        res.writeHead(200, {
+                            'Content-Type': 'text/plain;charset=UTF-8'//,
+                            //'Transfer-Encoding': 'chunked',
+                            //'Trailer': 'Content-MD5'
+                        });
+                        res.end(fn_res);
 
 
-                } else if (tfr === 'o' || tfr === 'a') {
-                    // Just write it as a string for the moment I think?
-                    //   Or always encode as JSON?
+                    } else if (tfr === 'o' || tfr === 'a') {
+                        // Just write it as a string for the moment I think?
+                        //   Or always encode as JSON?
 
-                    // text/plain;charset=UTF-8
+                        // text/plain;charset=UTF-8
 
-                    res.writeHead(200, {
-                        'Content-Type': 'application/json'//,
-                        //'Transfer-Encoding': 'chunked',
-                        //'Trailer': 'Content-MD5'
-                    });
-                    res.end(JSON.stringify(fn_res));
+                        res.writeHead(200, {
+                            'Content-Type': 'application/json'//,
+                            //'Transfer-Encoding': 'chunked',
+                            //'Trailer': 'Content-MD5'
+                        });
+                        res.end(JSON.stringify(fn_res));
 
 
-                } else {
-                    console.log('tfr', tfr);
-                    console.trace();
-                    throw 'NYI';
+                    } else {
+                        console.log('tfr', tfr);
+                        console.trace();
+                        throw 'NYI';
+                    }
+                } catch (err) {
+                    console.error('Function execution error:', err);
+                    if (!res.headersSent) {
+                        res.writeHead(500, {
+                            'Content-Type': 'application/json'
+                        });
+                        res.end(JSON.stringify({ error: err.message }));
+                    }
                 }