javascript-solid-server 0.0.9 → 0.0.11

package/package.json

@@ -1,16 +1,29 @@
 {
   "name": "javascript-solid-server",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "description": "A minimal, fast Solid server",
   "main": "src/index.js",
   "type": "module",
+  "bin": {
+    "jss": "./bin/jss.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/JavaScriptSolidServer/JavaScriptSolidServer.git"
+  },
+  "bugs": {
+    "url": "https://github.com/JavaScriptSolidServer/JavaScriptSolidServer/issues"
+  },
+  "homepage": "https://github.com/JavaScriptSolidServer/JavaScriptSolidServer#readme",
   "scripts": {
-    "start": "node src/index.js",
-    "dev": "node --watch src/index.js",
-    "test": "node --test --test-concurrency=1"
+    "start": "node bin/jss.js start",
+    "dev": "node --watch bin/jss.js start",
+    "test": "node --test --test-concurrency=1",
+    "benchmark": "node benchmark.js"
   },
   "dependencies": {
     "@fastify/websocket": "^8.3.1",
+    "commander": "^14.0.2",
     "fastify": "^4.25.2",
     "fs-extra": "^11.2.0",
     "jose": "^6.1.3",
@@ -25,5 +38,8 @@
     "linked-data",
     "decentralized"
   ],
-  "license": "MIT"
+  "license": "MIT",
+  "devDependencies": {
+    "autocannon": "^8.0.0"
+  }
 }

package/src/config.js

@@ -0,0 +1,185 @@
+/**
+ * Configuration Loading
+ *
+ * Loads config from (in order of precedence):
+ * 1. CLI arguments (highest)
+ * 2. Environment variables (JSS_*)
+ * 3. Config file (config.json)
+ * 4. Defaults (lowest)
+ */
+
+import fs from 'fs-extra';
+import path from 'path';
+
+/**
+ * Default configuration values
+ */
+export const defaults = {
+  // Server
+  port: 3000,
+  host: '0.0.0.0',
+  root: './data',
+
+  // SSL
+  sslKey: null,
+  sslCert: null,
+
+  // Features
+  multiuser: true,
+  conneg: false,
+  notifications: false,
+
+  // Logging
+  logger: true,
+  quiet: false,
+
+  // Paths
+  configPath: './.jss',
+};
+
+/**
+ * Map of environment variable names to config keys
+ */
+const envMap = {
+  JSS_PORT: 'port',
+  JSS_HOST: 'host',
+  JSS_ROOT: 'root',
+  JSS_SSL_KEY: 'sslKey',
+  JSS_SSL_CERT: 'sslCert',
+  JSS_MULTIUSER: 'multiuser',
+  JSS_CONNEG: 'conneg',
+  JSS_NOTIFICATIONS: 'notifications',
+  JSS_QUIET: 'quiet',
+  JSS_CONFIG_PATH: 'configPath',
+};
+
+/**
+ * Parse a value from environment variable string
+ */
+function parseEnvValue(value, key) {
+  if (value === undefined) return undefined;
+
+  // Boolean values
+  if (value.toLowerCase() === 'true') return true;
+  if (value.toLowerCase() === 'false') return false;
+
+  // Numeric values for known numeric keys
+  if (key === 'port' && !isNaN(value)) {
+    return parseInt(value, 10);
+  }
+
+  return value;
+}
+
+/**
+ * Load configuration from environment variables
+ */
+function loadEnvConfig() {
+  const config = {};
+
+  for (const [envVar, configKey] of Object.entries(envMap)) {
+    const value = process.env[envVar];
+    if (value !== undefined) {
+      config[configKey] = parseEnvValue(value, configKey);
+    }
+  }
+
+  return config;
+}
+
+/**
+ * Load configuration from a JSON file
+ */
+async function loadFileConfig(configFile) {
+  if (!configFile) return {};
+
+  try {
+    const fullPath = path.resolve(configFile);
+    if (await fs.pathExists(fullPath)) {
+      const content = await fs.readFile(fullPath, 'utf8');
+      return JSON.parse(content);
+    }
+  } catch (e) {
+    console.error(`Warning: Failed to load config file: ${e.message}`);
+  }
+
+  return {};
+}
+
+/**
+ * Merge configuration sources
+ * @param {object} cliOptions - Options from command line
+ * @param {string} configFile - Path to config file (optional)
+ * @returns {Promise<object>} Merged configuration
+ */
+export async function loadConfig(cliOptions = {}, configFile = null) {
+  // Load from file first
+  const fileConfig = await loadFileConfig(configFile || cliOptions.config);
+
+  // Load from environment
+  const envConfig = loadEnvConfig();
+
+  // Merge in order: defaults < file < env < cli
+  const config = {
+    ...defaults,
+    ...fileConfig,
+    ...envConfig,
+    ...filterUndefined(cliOptions),
+  };
+
+  // Derive additional settings
+  if (config.quiet) {
+    config.logger = false;
+  }
+
+  // Validate SSL config
+  if ((config.sslKey && !config.sslCert) || (!config.sslKey && config.sslCert)) {
+    throw new Error('Both --ssl-key and --ssl-cert must be provided together');
+  }
+
+  config.ssl = !!(config.sslKey && config.sslCert);
+
+  return config;
+}
+
+/**
+ * Filter out undefined values from an object
+ */
+function filterUndefined(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value !== undefined) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+/**
+ * Save configuration to a file
+ */
+export async function saveConfig(config, configFile) {
+  const toSave = { ...config };
+  // Remove derived/runtime values
+  delete toSave.ssl;
+  delete toSave.logger;
+
+  await fs.ensureDir(path.dirname(configFile));
+  await fs.writeFile(configFile, JSON.stringify(toSave, null, 2));
+}
+
+/**
+ * Print configuration (for debugging)
+ */
+export function printConfig(config) {
+  console.log('\nConfiguration:');
+  console.log('─'.repeat(40));
+  console.log(`  Port:          ${config.port}`);
+  console.log(`  Host:          ${config.host}`);
+  console.log(`  Root:          ${path.resolve(config.root)}`);
+  console.log(`  SSL:           ${config.ssl ? 'enabled' : 'disabled'}`);
+  console.log(`  Multi-user:    ${config.multiuser}`);
+  console.log(`  Conneg:        ${config.conneg}`);
+  console.log(`  Notifications: ${config.notifications}`);
+  console.log('─'.repeat(40));
+}

package/src/handlers/resource.js

@@ -3,6 +3,7 @@ import { getAllHeaders } from '../ldp/headers.js';
 import { generateContainerJsonLd, serializeJsonLd } from '../ldp/container.js';
 import { isContainer, getContentType, isRdfContentType } from '../utils/url.js';
 import { parseN3Patch, applyN3Patch, validatePatch } from '../patch/n3-patch.js';
+import { parseSparqlUpdate, applySparqlUpdate } from '../patch/sparql-update.js';
 import {
   selectContentType,
   canAcceptInput,
@@ -12,6 +13,7 @@ import {
   RDF_TYPES
 } from '../rdf/conneg.js';
 import { emitChange } from '../notifications/events.js';
+import { checkIfMatch, checkIfNoneMatchForGet, checkIfNoneMatchForWrite } from '../utils/conditional.js';
 
 /**
  * Handle GET request
@@ -24,6 +26,15 @@ export async function handleGet(request, reply) {
     return reply.code(404).send({ error: 'Not Found' });
   }
 
+  // Check If-None-Match for conditional GET (304 Not Modified)
+  const ifNoneMatch = request.headers['if-none-match'];
+  if (ifNoneMatch) {
+    const check = checkIfNoneMatchForGet(ifNoneMatch, stats.etag);
+    if (!check.ok && check.notModified) {
+      return reply.code(304).send();
+    }
+  }
+
   const origin = request.headers.origin;
   const resourceUrl = `${request.protocol}://${request.hostname}${urlPath}`;
 
@@ -185,8 +196,28 @@ export async function handlePut(request, reply) {
     });
   }
 
-  // Check if resource already exists
-  const existed = await storage.exists(urlPath);
+  // Check if resource already exists and get current ETag
+  const stats = await storage.stat(urlPath);
+  const existed = stats !== null;
+  const currentEtag = stats?.etag || null;
+
+  // Check If-Match header (for safe updates)
+  const ifMatch = request.headers['if-match'];
+  if (ifMatch) {
+    const check = checkIfMatch(ifMatch, currentEtag);
+    if (!check.ok) {
+      return reply.code(check.status).send({ error: check.error });
+    }
+  }
+
+  // Check If-None-Match header (for create-only semantics)
+  const ifNoneMatch = request.headers['if-none-match'];
+  if (ifNoneMatch) {
+    const check = checkIfNoneMatchForWrite(ifNoneMatch, currentEtag);
+    if (!check.ok) {
+      return reply.code(check.status).send({ error: check.error });
+    }
+  }
 
   // Get content from request body
   let content = request.body;
@@ -242,11 +273,21 @@ export async function handlePut(request, reply) {
 export async function handleDelete(request, reply) {
   const urlPath = request.url.split('?')[0];
 
-  const existed = await storage.exists(urlPath);
-  if (!existed) {
+  // Check if resource exists and get current ETag
+  const stats = await storage.stat(urlPath);
+  if (!stats) {
     return reply.code(404).send({ error: 'Not Found' });
   }
 
+  // Check If-Match header (for safe deletes)
+  const ifMatch = request.headers['if-match'];
+  if (ifMatch) {
+    const check = checkIfMatch(ifMatch, stats.etag);
+    if (!check.ok) {
+      return reply.code(check.status).send({ error: check.error });
+    }
+  }
+
   const success = await storage.remove(urlPath);
   if (!success) {
     return reply.code(500).send({ error: 'Delete failed' });
@@ -274,10 +315,12 @@ export async function handleOptions(request, reply) {
 
   const origin = request.headers.origin;
   const resourceUrl = `${request.protocol}://${request.hostname}${urlPath}`;
+  const connegEnabled = request.connegEnabled || false;
   const headers = getAllHeaders({
     isContainer: stats?.isDirectory || isContainer(urlPath),
     origin,
-    resourceUrl
+    resourceUrl,
+    connegEnabled
   });
 
   Object.entries(headers).forEach(([k, v]) => reply.header(k, v));
@@ -286,7 +329,7 @@ export async function handleOptions(request, reply) {
 
 /**
  * Handle PATCH request
- * Supports N3 Patch format (text/n3) for updating RDF resources
+ * Supports N3 Patch format (text/n3) and SPARQL Update for updating RDF resources
  */
 export async function handlePatch(request, reply) {
   const urlPath = request.url.split('?')[0];
@@ -298,14 +341,13 @@ export async function handlePatch(request, reply) {
 
   // Check content type
   const contentType = request.headers['content-type'] || '';
-  const isN3Patch = contentType.includes('text/n3') ||
-                    contentType.includes('application/n3') ||
-                    contentType.includes('application/sparql-update');
+  const isN3Patch = contentType.includes('text/n3') || contentType.includes('application/n3');
+  const isSparqlUpdate = contentType.includes('application/sparql-update');
 
-  if (!isN3Patch) {
+  if (!isN3Patch && !isSparqlUpdate) {
     return reply.code(415).send({
       error: 'Unsupported Media Type',
-      message: 'PATCH requires Content-Type: text/n3 for N3 Patch format'
+      message: 'PATCH requires Content-Type: text/n3 (N3 Patch) or application/sparql-update (SPARQL Update)'
     });
   }
 
@@ -315,6 +357,15 @@ export async function handlePatch(request, reply) {
     return reply.code(404).send({ error: 'Not Found' });
   }
 
+  // Check If-Match header (for safe updates)
+  const ifMatch = request.headers['if-match'];
+  if (ifMatch) {
+    const check = checkIfMatch(ifMatch, stats.etag);
+    if (!check.ok) {
+      return reply.code(check.status).send({ error: check.error });
+    }
+  }
+
   // Read existing content
   const existingContent = await storage.read(urlPath);
   if (existingContent === null) {
@@ -338,31 +389,49 @@ export async function handlePatch(request, reply) {
     : request.body;
 
   const resourceUrl = `${request.protocol}://${request.hostname}${urlPath}`;
-  let patch;
-  try {
-    patch = parseN3Patch(patchContent, resourceUrl);
-  } catch (e) {
-    return reply.code(400).send({
-      error: 'Bad Request',
-      message: 'Invalid N3 Patch format: ' + e.message
-    });
-  }
 
-  // Validate that deletes exist (optional strict mode)
-  // const validation = validatePatch(document, patch, resourceUrl);
-  // if (!validation.valid) {
-  //   return reply.code(409).send({ error: 'Conflict', message: validation.error });
-  // }
-
-  // Apply the patch
   let updatedDocument;
-  try {
-    updatedDocument = applyN3Patch(document, patch, resourceUrl);
-  } catch (e) {
-    return reply.code(409).send({
-      error: 'Conflict',
-      message: 'Failed to apply patch: ' + e.message
-    });
+
+  if (isSparqlUpdate) {
+    // Handle SPARQL Update
+    let update;
+    try {
+      update = parseSparqlUpdate(patchContent, resourceUrl);
+    } catch (e) {
+      return reply.code(400).send({
+        error: 'Bad Request',
+        message: 'Invalid SPARQL Update: ' + e.message
+      });
+    }
+
+    try {
+      updatedDocument = applySparqlUpdate(document, update, resourceUrl);
+    } catch (e) {
+      return reply.code(409).send({
+        error: 'Conflict',
+        message: 'Failed to apply SPARQL Update: ' + e.message
+      });
+    }
+  } else {
+    // Handle N3 Patch
+    let patch;
+    try {
+      patch = parseN3Patch(patchContent, resourceUrl);
+    } catch (e) {
+      return reply.code(400).send({
+        error: 'Bad Request',
+        message: 'Invalid N3 Patch format: ' + e.message
+      });
+    }
+
+    try {
+      updatedDocument = applyN3Patch(document, patch, resourceUrl);
+    } catch (e) {
+      return reply.code(409).send({
+        error: 'Conflict',
+        message: 'Failed to apply patch: ' + e.message
+      });
+    }
   }
 
   // Write updated document