javascript-solid-server 0.0.9 → 0.0.11

package/benchmark.js

@@ -1,286 +1,182 @@
-import fetch from 'node-fetch';
-import { performance } from 'perf_hooks';
-import { promises as fs } from 'fs';
-import path from 'path';
-
-// Configuration
-const config = {
-  baseUrl: 'http://nostr.social:3000',
-  concurrentUsers: [1, 5, 10, 50, 100], // Different concurrency levels to test
-  operations: 100, // Operations per user
-  testDuration: 30000, // 30 seconds per test
-  testUserPrefix: 'testuser',
-  testPassword: 'benchmark123',
-  results: {
-    registerTime: [],
-    loginTime: [],
-    readTime: [],
-    writeTime: [],
-    deleteTime: [],
-    throughput: []
-  }
-};
-
-// Store tokens for authenticated requests
-const tokens = new Map();
-
-// Utility function to measure execution time
-async function measureTime (fn) {
-  const start = performance.now();
-  const result = await fn();
-  const end = performance.now();
-  return { result, time: end - start };
-}
-
-// Register a test user
-async function registerUser (username) {
-  const { result, time } = await measureTime(async () => {
-    const response = await fetch(`${config.baseUrl}/register`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        username,
-        password: config.testPassword,
-        email: `${username}@benchmark.test`
-      })
-    });
-    return response.json();
+#!/usr/bin/env node
+/**
+ * Benchmark script for JavaScript Solid Server
+ *
+ * Measures throughput and latency for common operations.
+ * Run: node benchmark.js
+ */
+
+import autocannon from 'autocannon';
+import { createServer } from './src/server.js';
+import fs from 'fs-extra';
+
+const PORT = 3030;
+const DURATION = 10; // seconds per test
+const CONNECTIONS = 10;
+
+let server;
+let token;
+
+async function setup() {
+  // Clean data directory
+  await fs.emptyDir('./data');
+
+  // Start server (no logging for clean benchmark)
+  server = createServer({ logger: false });
+  await server.listen({ port: PORT, host: '127.0.0.1' });
+
+  // Create a test pod
+  const res = await fetch(`http://127.0.0.1:${PORT}/.pods`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ name: 'bench' })
   });
+  const data = await res.json();
+  token = data.token;
 
-  config.results.registerTime.push(time);
-  return result;
-}
-
-// Login a test user
-async function loginUser (username) {
-  const { result, time } = await measureTime(async () => {
-    const response = await fetch(`${config.baseUrl}/login`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        username,
-        password: config.testPassword
-      })
-    });
-    return response.json();
-  });
-
-  config.results.loginTime.push(time);
-
-  if (result.id_token) {
-    tokens.set(username, result.id_token);
-  }
-
-  return result;
-}
-
-// Create a resource
-async function createResource (username, resourcePath, content = null) {
-  const token = tokens.get(username);
-  if (!token) throw new Error(`No token for user ${username}`);
-
-  const turtleContent = content || `
-    @prefix foaf: <http://xmlns.com/foaf/0.1/>.
-    <#me> a foaf:Person;
-      foaf:name "${username}";
-      foaf:mbox <mailto:${username}@benchmark.test>.
-  `;
-
-  const { result, time } = await measureTime(async () => {
-    const response = await fetch(`${config.baseUrl}/${username}/${resourcePath}`, {
+  // Create some test resources
+  for (let i = 0; i < 100; i++) {
+    await fetch(`http://127.0.0.1:${PORT}/bench/public/item${i}.json`, {
       method: 'PUT',
       headers: {
-        'Content-Type': 'text/turtle',
+        'Content-Type': 'application/ld+json',
         'Authorization': `Bearer ${token}`
       },
-      body: turtleContent
+      body: JSON.stringify({ '@id': `#item${i}`, 'http://example.org/value': i })
     });
-    return response.status;
-  });
+  }
 
-  config.results.writeTime.push(time);
-  return result;
+  console.log('Setup complete: created pod with 100 resources\n');
 }
 
-// Read a resource
-async function readResource (username, resourcePath) {
-  const token = tokens.get(username);
-  if (!token) throw new Error(`No token for user ${username}`);
+async function teardown() {
+  await server.close();
+  await fs.emptyDir('./data');
+}
 
-  const { result, time } = await measureTime(async () => {
-    const response = await fetch(`${config.baseUrl}/${username}/${resourcePath}`, {
-      method: 'GET',
-      headers: {
-        'Authorization': `Bearer ${token}`
-      }
+function runBenchmark(opts) {
+  return new Promise((resolve) => {
+    const instance = autocannon({
+      ...opts,
+      duration: DURATION,
+      connections: CONNECTIONS,
+    }, (err, result) => {
+      resolve(result);
     });
-    return response.status;
-  });
 
-  config.results.readTime.push(time);
-  return result;
+    autocannon.track(instance, { renderProgressBar: false });
+  });
 }
 
-// Delete a resource
-async function deleteResource (username, resourcePath) {
-  const token = tokens.get(username);
-  if (!token) throw new Error(`No token for user ${username}`);
+function formatResult(result) {
+  return {
+    'Requests/sec': Math.round(result.requests.average),
+    'Latency avg': `${result.latency.average.toFixed(2)}ms`,
+    'Latency p99': `${result.latency.p99.toFixed(2)}ms`,
+    'Throughput': `${(result.throughput.average / 1024 / 1024).toFixed(2)} MB/s`
+  };
+}
 
-  const { result, time } = await measureTime(async () => {
-    const response = await fetch(`${config.baseUrl}/${username}/${resourcePath}`, {
-      method: 'DELETE',
-      headers: {
-        'Authorization': `Bearer ${token}`
-      }
-    });
-    return response.status;
+async function benchmarkGET() {
+  console.log('📖 Benchmarking GET (read resource)...');
+  const result = await runBenchmark({
+    url: `http://127.0.0.1:${PORT}/bench/public/item0.json`,
+    method: 'GET'
   });
-
-  config.results.deleteTime.push(time);
-  return result;
+  return formatResult(result);
 }
 
-// Run benchmark for specific concurrency
-async function runBenchmark (concurrentUsers) {
-  console.log(`\n=== Running benchmark with ${concurrentUsers} concurrent users ===`);
-
-  // Create test users
-  console.log('Creating test users...');
-  const users = [];
-  for (let i = 0; i < concurrentUsers; i++) {
-    const username = `${config.testUserPrefix}${i}`;
-    users.push(username);
-    await registerUser(username);
-    await loginUser(username);
-  }
+async function benchmarkGETContainer() {
+  console.log('📂 Benchmarking GET (container listing)...');
+  const result = await runBenchmark({
+    url: `http://127.0.0.1:${PORT}/bench/public/`,
+    method: 'GET'
+  });
+  return formatResult(result);
+}
 
-  // Prepare operation queue (read/write/delete)
-  const operations = [];
-  for (const username of users) {
-    for (let i = 0; i < config.operations; i++) {
-      const resourcePath = `benchmark/resource${i}.ttl`;
-      operations.push(async () => await createResource(username, resourcePath));
-      operations.push(async () => await readResource(username, resourcePath));
-      operations.push(async () => await deleteResource(username, resourcePath));
+let putCounter = 1000;
+async function benchmarkPUT() {
+  console.log('✏️  Benchmarking PUT (create/update resource)...');
+  const result = await runBenchmark({
+    url: `http://127.0.0.1:${PORT}/bench/public/new`,
+    method: 'PUT',
+    headers: {
+      'Content-Type': 'application/ld+json',
+      'Authorization': `Bearer ${token}`
+    },
+    setupClient: (client) => {
+      client.setBody(JSON.stringify({ '@id': '#test', 'http://example.org/v': putCounter++ }));
     }
-  }
-
-  // Run operations with measured throughput
-  console.log(`Starting operations (${operations.length} total)...`);
-  const startTime = performance.now();
-  let completedOps = 0;
-  const endTime = startTime + config.testDuration;
-
-  // Create chunks of operations to run in parallel
-  const chunks = [];
-  const chunkSize = operations.length > 100 ? 100 : operations.length;
-
-  for (let i = 0; i < operations.length; i += chunkSize) {
-    chunks.push(operations.slice(i, i + chunkSize));
-  }
-
-  for (const chunk of chunks) {
-    if (performance.now() >= endTime) break;
-
-    await Promise.all(chunk.map(async (operation) => {
-      if (performance.now() < endTime) {
-        await operation();
-        completedOps++;
-      }
-    }));
-  }
-
-  // Calculate throughput (ops/sec)
-  const actualDuration = Math.min(performance.now() - startTime, config.testDuration);
-  const throughput = (completedOps / actualDuration) * 1000;
-  config.results.throughput.push({
-    concurrentUsers,
-    operations: completedOps,
-    duration: actualDuration,
-    throughput
   });
-
-  console.log(`Completed ${completedOps} operations in ${actualDuration.toFixed(2)}ms`);
-  console.log(`Throughput: ${throughput.toFixed(2)} operations/second`);
+  return formatResult(result);
 }
 
-// Generate report
-async function generateReport () {
-  // Calculate averages
-  const averages = {
-    register: calculateAverage(config.results.registerTime),
-    login: calculateAverage(config.results.loginTime),
-    read: calculateAverage(config.results.readTime),
-    write: calculateAverage(config.results.writeTime),
-    delete: calculateAverage(config.results.deleteTime)
-  };
+async function benchmarkPOST() {
+  console.log('📝 Benchmarking POST (create in container)...');
+  const result = await runBenchmark({
+    url: `http://127.0.0.1:${PORT}/bench/public/`,
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/ld+json',
+      'Authorization': `Bearer ${token}`
+    },
+    body: JSON.stringify({ '@id': '#new', 'http://example.org/created': true })
+  });
+  return formatResult(result);
+}
 
-  // Create report
-  const report = {
-    timestamp: new Date().toISOString(),
-    server: config.baseUrl,
-    testDuration: config.testDuration,
-    averageResponseTimes: averages,
-    throughputResults: config.results.throughput
-  };
+async function benchmarkOPTIONS() {
+  console.log('🔍 Benchmarking OPTIONS (discovery)...');
+  const result = await runBenchmark({
+    url: `http://127.0.0.1:${PORT}/bench/public/item0.json`,
+    method: 'OPTIONS'
+  });
+  return formatResult(result);
+}
 
-  // Save report to file
-  await fs.writeFile(
-    `benchmark-report-${new Date().toISOString().replace(/:/g, '-')}.json`,
-    JSON.stringify(report, null, 2)
-  );
+async function benchmarkHEAD() {
+  console.log('📋 Benchmarking HEAD (metadata only)...');
+  const result = await runBenchmark({
+    url: `http://127.0.0.1:${PORT}/bench/public/item0.json`,
+    method: 'HEAD'
+  });
+  return formatResult(result);
+}
 
-  // Display summary
-  console.log('\n=== BENCHMARK RESULTS ===');
-  console.log('Average Response Times (ms):');
-  console.log(`  Register: ${averages.register.toFixed(2)} ms`);
-  console.log(`  Login: ${averages.login.toFixed(2)} ms`);
-  console.log(`  Read: ${averages.read.toFixed(2)} ms`);
-  console.log(`  Write: ${averages.write.toFixed(2)} ms`);
-  console.log(`  Delete: ${averages.delete.toFixed(2)} ms`);
+async function main() {
+  console.log('🚀 JavaScript Solid Server Benchmark');
+  console.log('=====================================');
+  console.log(`Duration: ${DURATION}s per test, ${CONNECTIONS} concurrent connections\n`);
 
-  console.log('\nThroughput Results:');
-  config.results.throughput.forEach(result => {
-    console.log(`  ${result.concurrentUsers} users: ${result.throughput.toFixed(2)} ops/sec`);
-  });
+  await setup();
 
-  console.log('\nReport saved to file.');
-}
+  const results = {};
 
-// Calculate average of an array
-function calculateAverage (array) {
-  if (array.length === 0) return 0;
-  return array.reduce((sum, value) => sum + value, 0) / array.length;
-}
+  results['GET resource'] = await benchmarkGET();
+  results['GET container'] = await benchmarkGETContainer();
+  results['HEAD'] = await benchmarkHEAD();
+  results['OPTIONS'] = await benchmarkOPTIONS();
+  results['PUT'] = await benchmarkPUT();
+  results['POST'] = await benchmarkPOST();
 
-// Main benchmark function
-async function startBenchmark () {
-  console.log('=== JavaScript Solid Server Benchmark ===');
-  console.log(`Server URL: ${config.baseUrl}`);
-  console.log(`Test Duration: ${config.testDuration / 1000} seconds per concurrency level`);
+  console.log('\n📊 Results Summary');
+  console.log('==================\n');
 
-  try {
-    // Check if server is running
-    const response = await fetch(config.baseUrl);
-    if (response.status < 200 || response.status >= 500) {
-      throw new Error(`Server responded with status ${response.status}`);
-    }
-  } catch (error) {
-    console.error('Error connecting to server:', error.message);
-    console.error('Please make sure the server is running before starting the benchmark.');
-    return;
+  // Print as table
+  console.log('| Operation | Req/sec | Avg Latency | p99 Latency |');
+  console.log('|-----------|---------|-------------|-------------|');
+  for (const [op, data] of Object.entries(results)) {
+    console.log(`| ${op.padEnd(13)} | ${String(data['Requests/sec']).padStart(7)} | ${data['Latency avg'].padStart(11)} | ${data['Latency p99'].padStart(11)} |`);
   }
 
-  // Run tests for each concurrency level
-  for (const concurrentUsers of config.concurrentUsers) {
-    await runBenchmark(concurrentUsers);
-  }
+  console.log('\n');
+
+  await teardown();
 
-  // Generate final report
-  await generateReport();
+  // Output JSON for README
+  console.log('JSON results:');
+  console.log(JSON.stringify(results, null, 2));
 }
 
-// Start the benchmark
-startBenchmark().catch(error => {
-  console.error('Benchmark error:', error);
-}); 
+main().catch(console.error);

package/bin/jss.js

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+
+/**
+ * JavaScript Solid Server CLI
+ *
+ * Usage:
+ *   jss start [options]    Start the server
+ *   jss init               Initialize configuration
+ */
+
+import { Command } from 'commander';
+import { createServer } from '../src/server.js';
+import { loadConfig, saveConfig, printConfig, defaults } from '../src/config.js';
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import readline from 'readline';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(await fs.readFile(path.join(__dirname, '../package.json'), 'utf8'));
+
+const program = new Command();
+
+program
+  .name('jss')
+  .description('JavaScript Solid Server - A minimal, fast, JSON-LD native Solid server')
+  .version(pkg.version);
+
+/**
+ * Start command
+ */
+program
+  .command('start')
+  .description('Start the Solid server')
+  .option('-p, --port <number>', 'Port to listen on', parseInt)
+  .option('-h, --host <address>', 'Host to bind to')
+  .option('-r, --root <path>', 'Data directory')
+  .option('-c, --config <file>', 'Config file path')
+  .option('--ssl-key <path>', 'Path to SSL private key (PEM)')
+  .option('--ssl-cert <path>', 'Path to SSL certificate (PEM)')
+  .option('--multiuser', 'Enable multi-user mode')
+  .option('--no-multiuser', 'Disable multi-user mode')
+  .option('--conneg', 'Enable content negotiation (Turtle support)')
+  .option('--no-conneg', 'Disable content negotiation')
+  .option('--notifications', 'Enable WebSocket notifications')
+  .option('--no-notifications', 'Disable WebSocket notifications')
+  .option('-q, --quiet', 'Suppress log output')
+  .option('--print-config', 'Print configuration and exit')
+  .action(async (options) => {
+    try {
+      const config = await loadConfig(options, options.config);
+
+      if (options.printConfig) {
+        printConfig(config);
+        process.exit(0);
+      }
+
+      // Create and start server
+      const server = createServer({
+        logger: config.logger,
+        conneg: config.conneg,
+        notifications: config.notifications,
+        ssl: config.ssl ? {
+          key: await fs.readFile(config.sslKey),
+          cert: await fs.readFile(config.sslCert),
+        } : null,
+        root: config.root,
+      });
+
+      await server.listen({ port: config.port, host: config.host });
+
+      const protocol = config.ssl ? 'https' : 'http';
+      const address = config.host === '0.0.0.0' ? 'localhost' : config.host;
+
+      if (!config.quiet) {
+        console.log(`\n  JavaScript Solid Server v${pkg.version}`);
+        console.log(`  ${protocol}://${address}:${config.port}/`);
+        console.log(`\n  Data: ${path.resolve(config.root)}`);
+        if (config.ssl) console.log('  SSL:  enabled');
+        if (config.conneg) console.log('  Conneg: enabled');
+        if (config.notifications) console.log('  WebSocket: enabled');
+        console.log('\n  Press Ctrl+C to stop\n');
+      }
+
+      // Handle shutdown
+      const shutdown = async () => {
+        if (!config.quiet) console.log('\n  Shutting down...');
+        await server.close();
+        process.exit(0);
+      };
+
+      process.on('SIGINT', shutdown);
+      process.on('SIGTERM', shutdown);
+
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+
+/**
+ * Init command - interactive configuration
+ */
+program
+  .command('init')
+  .description('Initialize server configuration')
+  .option('-c, --config <file>', 'Config file path', './config.json')
+  .option('-y, --yes', 'Accept defaults without prompting')
+  .action(async (options) => {
+    const configFile = path.resolve(options.config);
+
+    // Check if config already exists
+    if (await fs.pathExists(configFile)) {
+      console.log(`Config file already exists: ${configFile}`);
+      const overwrite = options.yes ? true : await confirm('Overwrite?');
+      if (!overwrite) {
+        console.log('Aborted.');
+        process.exit(0);
+      }
+    }
+
+    let config;
+
+    if (options.yes) {
+      // Use defaults
+      config = { ...defaults };
+    } else {
+      // Interactive prompts
+      console.log('\n  JavaScript Solid Server Setup\n');
+
+      config = {
+        port: await prompt('Port', defaults.port),
+        root: await prompt('Data directory', defaults.root),
+        conneg: await confirm('Enable content negotiation (Turtle support)?', defaults.conneg),
+        notifications: await confirm('Enable WebSocket notifications?', defaults.notifications),
+      };
+
+      // Ask about SSL
+      const useSSL = await confirm('Configure SSL?', false);
+      if (useSSL) {
+        config.sslKey = await prompt('SSL key path', './ssl/key.pem');
+        config.sslCert = await prompt('SSL certificate path', './ssl/cert.pem');
+      }
+
+      console.log('');
+    }
+
+    // Save config
+    await saveConfig(config, configFile);
+    console.log(`Configuration saved to: ${configFile}`);
+
+    // Create data directory
+    const dataDir = path.resolve(config.root);
+    await fs.ensureDir(dataDir);
+    console.log(`Data directory created: ${dataDir}`);
+
+    console.log('\nRun `jss start` to start the server.\n');
+  });
+
+/**
+ * Helper: Prompt for input
+ */
+async function prompt(question, defaultValue) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  return new Promise((resolve) => {
+    const defaultStr = defaultValue !== undefined ? ` (${defaultValue})` : '';
+    rl.question(`  ${question}${defaultStr}: `, (answer) => {
+      rl.close();
+      const value = answer.trim() || defaultValue;
+      // Parse numbers
+      if (typeof defaultValue === 'number' && !isNaN(value)) {
+        resolve(parseInt(value, 10));
+      } else {
+        resolve(value);
+      }
+    });
+  });
+}
+
+/**
+ * Helper: Confirm yes/no
+ */
+async function confirm(question, defaultValue = false) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  return new Promise((resolve) => {
+    const hint = defaultValue ? '[Y/n]' : '[y/N]';
+    rl.question(`  ${question} ${hint}: `, (answer) => {
+      rl.close();
+      const normalized = answer.trim().toLowerCase();
+      if (normalized === '') {
+        resolve(defaultValue);
+      } else {
+        resolve(normalized === 'y' || normalized === 'yes');
+      }
+    });
+  });
+}
+
+// Parse and run
+program.parse();