fastpod 0.0.1 → 0.0.3

package/README.md

@@ -16,7 +16,33 @@ npx fastpod
 # That's it! Your Solid pod is running at http://localhost:5444
 ```
 
-## ⚡ Features
+## ⚡ Performance
+
+fastpod lives up to its name. Here are real benchmark results:
+
+```
+🏁 Benchmark Results
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  Startup Time:        ~3 seconds
+  First Response:      3ms
+
+  Average Response Times:
+    GET:     0.63ms
+    PUT:     0.84ms
+    POST:    0.64ms
+    DELETE:  0.44ms
+
+  Throughput:          1,569 requests/sec
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+**What this means:**
+- 🚀 Server starts in ~3 seconds from `npx fastpod`
+- ⚡ Sub-millisecond response times for all operations
+- 💪 Handles 1,500+ requests per second
+- 🎯 Production-ready performance out of the box
+
+## ✨ Features
 
 - ✅ **Zero configuration** - Just works
 - ✅ **Lightning fast** - Server starts in seconds
@@ -92,8 +118,10 @@ npx fastpod
 
 ## 🎯 Why fastpod?
 
-- **Fast to type**: Just 7 characters
-- **Fast to start**: Server running in seconds
+- **Fast to type**: Just 7 characters (`fastpod`)
+- **Fast to start**: Server ready in 3 seconds
+- **Fast to respond**: Sub-millisecond response times (0.44-0.84ms)
+- **Fast to scale**: 1,500+ requests/second throughput
 - **Fast to learn**: Zero configuration needed
 - **Fast to deploy**: One command and you're live
 

package/benchmark.js

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+
+/**
+ * Benchmark script for fastpod
+ * Tests startup time, response time, and throughput
+ */
+
+import { spawn } from 'child_process';
+import { setTimeout as sleep } from 'timers/promises';
+
+const BENCHMARK_PORT = 5555;
+const BASE_URL = `http://localhost:${BENCHMARK_PORT}`;
+const TEST_ITERATIONS = 100;
+
+console.log('🏁 fastpod Benchmark Suite\n');
+
+// Track metrics
+const metrics = {
+  startupTime: 0,
+  firstResponseTime: 0,
+  getRequests: [],
+  putRequests: [],
+  postRequests: [],
+  deleteRequests: []
+};
+
+// Start the server
+console.log('Starting fastpod server...');
+const startTime = Date.now();
+
+const server = spawn('node', ['node_modules/.bin/jspod', '--port', BENCHMARK_PORT, '--no-auth', '--root', './bench-data'], {
+  stdio: 'pipe',
+  env: { ...process.env }
+});
+
+// Wait for server to be ready
+async function waitForServer() {
+  const maxAttempts = 30;
+  for (let i = 0; i < maxAttempts; i++) {
+    try {
+      const response = await fetch(BASE_URL);
+      if (response.ok || response.status === 404) {
+        return true;
+      }
+    } catch (e) {
+      await sleep(500);
+    }
+  }
+  throw new Error('Server failed to start');
+}
+
+try {
+  await waitForServer();
+  metrics.startupTime = Date.now() - startTime;
+  console.log(`✓ Server started in ${metrics.startupTime}ms\n`);
+
+  // Test first response time
+  console.log('Testing first response time...');
+  const firstReqStart = Date.now();
+  await fetch(BASE_URL);
+  metrics.firstResponseTime = Date.now() - firstReqStart;
+  console.log(`✓ First response: ${metrics.firstResponseTime}ms\n`);
+
+  // Benchmark GET requests
+  console.log(`Benchmarking GET requests (${TEST_ITERATIONS} iterations)...`);
+  for (let i = 0; i < TEST_ITERATIONS; i++) {
+    const start = Date.now();
+    await fetch(BASE_URL);
+    metrics.getRequests.push(Date.now() - start);
+  }
+  const avgGet = (metrics.getRequests.reduce((a, b) => a + b, 0) / metrics.getRequests.length).toFixed(2);
+  const minGet = Math.min(...metrics.getRequests);
+  const maxGet = Math.max(...metrics.getRequests);
+  console.log(`✓ GET avg: ${avgGet}ms, min: ${minGet}ms, max: ${maxGet}ms`);
+
+  // Benchmark PUT requests
+  console.log(`\nBenchmarking PUT requests (${TEST_ITERATIONS} iterations)...`);
+  for (let i = 0; i < TEST_ITERATIONS; i++) {
+    const start = Date.now();
+    await fetch(`${BASE_URL}/test-${i}.txt`, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'text/plain' },
+      body: `Test data ${i}`
+    });
+    metrics.putRequests.push(Date.now() - start);
+  }
+  const avgPut = (metrics.putRequests.reduce((a, b) => a + b, 0) / metrics.putRequests.length).toFixed(2);
+  const minPut = Math.min(...metrics.putRequests);
+  const maxPut = Math.max(...metrics.putRequests);
+  console.log(`✓ PUT avg: ${avgPut}ms, min: ${minPut}ms, max: ${maxPut}ms`);
+
+  // Benchmark POST requests
+  console.log(`\nBenchmarking POST requests (${TEST_ITERATIONS} iterations)...`);
+  for (let i = 0; i < TEST_ITERATIONS; i++) {
+    const start = Date.now();
+    await fetch(BASE_URL, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'text/plain',
+        'Slug': `post-${i}.txt`
+      },
+      body: `Posted data ${i}`
+    });
+    metrics.postRequests.push(Date.now() - start);
+  }
+  const avgPost = (metrics.postRequests.reduce((a, b) => a + b, 0) / metrics.postRequests.length).toFixed(2);
+  const minPost = Math.min(...metrics.postRequests);
+  const maxPost = Math.max(...metrics.postRequests);
+  console.log(`✓ POST avg: ${avgPost}ms, min: ${minPost}ms, max: ${maxPost}ms`);
+
+  // Benchmark DELETE requests
+  console.log(`\nBenchmarking DELETE requests (${TEST_ITERATIONS} iterations)...`);
+  for (let i = 0; i < TEST_ITERATIONS; i++) {
+    const start = Date.now();
+    await fetch(`${BASE_URL}/test-${i}.txt`, {
+      method: 'DELETE'
+    });
+    metrics.deleteRequests.push(Date.now() - start);
+  }
+  const avgDelete = (metrics.deleteRequests.reduce((a, b) => a + b, 0) / metrics.deleteRequests.length).toFixed(2);
+  const minDelete = Math.min(...metrics.deleteRequests);
+  const maxDelete = Math.max(...metrics.deleteRequests);
+  console.log(`✓ DELETE avg: ${avgDelete}ms, min: ${minDelete}ms, max: ${maxDelete}ms`);
+
+  // Calculate throughput
+  const totalRequests = TEST_ITERATIONS * 4; // GET, PUT, POST, DELETE
+  const totalTime = metrics.getRequests.reduce((a, b) => a + b, 0) +
+                    metrics.putRequests.reduce((a, b) => a + b, 0) +
+                    metrics.postRequests.reduce((a, b) => a + b, 0) +
+                    metrics.deleteRequests.reduce((a, b) => a + b, 0);
+  const throughput = (totalRequests / (totalTime / 1000)).toFixed(2);
+
+  // Display summary
+  console.log('\n' + '='.repeat(60));
+  console.log('📊 Benchmark Results Summary');
+  console.log('='.repeat(60));
+  console.log(`Startup Time:        ${metrics.startupTime}ms`);
+  console.log(`First Response:      ${metrics.firstResponseTime}ms`);
+  console.log(`\nAverage Response Times:`);
+  console.log(`  GET:    ${avgGet}ms`);
+  console.log(`  PUT:    ${avgPut}ms`);
+  console.log(`  POST:   ${avgPost}ms`);
+  console.log(`  DELETE: ${avgDelete}ms`);
+  console.log(`\nThroughput:          ${throughput} req/sec`);
+  console.log(`Total Requests:      ${totalRequests}`);
+  console.log('='.repeat(60));
+
+} catch (error) {
+  console.error('Benchmark failed:', error.message);
+} finally {
+  // Cleanup
+  console.log('\nCleaning up...');
+  server.kill('SIGTERM');
+  await sleep(1000);
+  process.exit(0);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastpod",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Fast Solid Pod - The fastest way to run a Solid pod",
   "type": "module",
   "main": "index.js",
@@ -36,6 +36,6 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
-    "jspod": "^0.0.3"
+    "jspod": "^0.0.4"
   }
 }