javascript-solid-server 0.0.2

package/src/handlers/resource.js

@@ -0,0 +1,162 @@
+import * as storage from '../storage/filesystem.js';
+import { getAllHeaders } from '../ldp/headers.js';
+import { generateContainerJsonLd, serializeJsonLd } from '../ldp/container.js';
+import { isContainer, getContentType, isRdfContentType } from '../utils/url.js';
+
+/**
+ * Handle GET request
+ */
+export async function handleGet(request, reply) {
+  const urlPath = request.url.split('?')[0]; // Remove query string
+  const stats = await storage.stat(urlPath);
+
+  if (!stats) {
+    return reply.code(404).send({ error: 'Not Found' });
+  }
+
+  const origin = request.headers.origin;
+
+  // Handle container
+  if (stats.isDirectory) {
+    const entries = await storage.listContainer(urlPath);
+    const baseUrl = `${request.protocol}://${request.hostname}${urlPath}`;
+    const jsonLd = generateContainerJsonLd(baseUrl, entries || []);
+
+    const headers = getAllHeaders({
+      isContainer: true,
+      etag: stats.etag,
+      contentType: 'application/ld+json',
+      origin
+    });
+
+    Object.entries(headers).forEach(([k, v]) => reply.header(k, v));
+    return reply.send(serializeJsonLd(jsonLd));
+  }
+
+  // Handle resource
+  const content = await storage.read(urlPath);
+  if (content === null) {
+    return reply.code(500).send({ error: 'Read error' });
+  }
+
+  const contentType = getContentType(urlPath);
+  const headers = getAllHeaders({
+    isContainer: false,
+    etag: stats.etag,
+    contentType,
+    origin
+  });
+
+  Object.entries(headers).forEach(([k, v]) => reply.header(k, v));
+  return reply.send(content);
+}
+
+/**
+ * Handle HEAD request
+ */
+export async function handleHead(request, reply) {
+  const urlPath = request.url.split('?')[0];
+  const stats = await storage.stat(urlPath);
+
+  if (!stats) {
+    return reply.code(404).send();
+  }
+
+  const origin = request.headers.origin;
+  const contentType = stats.isDirectory ? 'application/ld+json' : getContentType(urlPath);
+
+  const headers = getAllHeaders({
+    isContainer: stats.isDirectory,
+    etag: stats.etag,
+    contentType,
+    origin
+  });
+
+  if (!stats.isDirectory) {
+    headers['Content-Length'] = stats.size;
+  }
+
+  Object.entries(headers).forEach(([k, v]) => reply.header(k, v));
+  return reply.code(200).send();
+}
+
+/**
+ * Handle PUT request
+ */
+export async function handlePut(request, reply) {
+  const urlPath = request.url.split('?')[0];
+
+  // Don't allow PUT to containers
+  if (isContainer(urlPath)) {
+    return reply.code(409).send({ error: 'Cannot PUT to container. Use POST instead.' });
+  }
+
+  // Check if resource already exists
+  const existed = await storage.exists(urlPath);
+
+  // Get content from request body
+  let content = request.body;
+
+  // Handle raw body for non-JSON content types
+  if (Buffer.isBuffer(content)) {
+    // Already a buffer, use as-is
+  } else if (typeof content === 'string') {
+    content = Buffer.from(content);
+  } else if (content && typeof content === 'object') {
+    content = Buffer.from(JSON.stringify(content));
+  } else {
+    content = Buffer.from('');
+  }
+
+  const success = await storage.write(urlPath, content);
+  if (!success) {
+    return reply.code(500).send({ error: 'Write failed' });
+  }
+
+  const origin = request.headers.origin;
+  const headers = getAllHeaders({ isContainer: false, origin });
+  headers['Location'] = `${request.protocol}://${request.hostname}${urlPath}`;
+
+  Object.entries(headers).forEach(([k, v]) => reply.header(k, v));
+  return reply.code(existed ? 204 : 201).send();
+}
+
+/**
+ * Handle DELETE request
+ */
+export async function handleDelete(request, reply) {
+  const urlPath = request.url.split('?')[0];
+
+  const existed = await storage.exists(urlPath);
+  if (!existed) {
+    return reply.code(404).send({ error: 'Not Found' });
+  }
+
+  const success = await storage.remove(urlPath);
+  if (!success) {
+    return reply.code(500).send({ error: 'Delete failed' });
+  }
+
+  const origin = request.headers.origin;
+  const headers = getAllHeaders({ isContainer: false, origin });
+  Object.entries(headers).forEach(([k, v]) => reply.header(k, v));
+
+  return reply.code(204).send();
+}
+
+/**
+ * Handle OPTIONS request
+ */
+export async function handleOptions(request, reply) {
+  const urlPath = request.url.split('?')[0];
+  const stats = await storage.stat(urlPath);
+
+  const origin = request.headers.origin;
+  const headers = getAllHeaders({
+    isContainer: stats?.isDirectory || isContainer(urlPath),
+    origin
+  });
+
+  Object.entries(headers).forEach(([k, v]) => reply.header(k, v));
+  return reply.code(204).send();
+}

package/src/index.js

@@ -0,0 +1,8 @@
+import { startServer } from './server.js';
+
+const PORT = process.env.PORT || 3000;
+const HOST = process.env.HOST || '0.0.0.0';
+
+startServer(PORT, HOST).then(() => {
+  console.log(`JavaScript Solid Server running at http://${HOST}:${PORT}`);
+});

package/src/ldp/container.js

@@ -0,0 +1,43 @@
+/**
+ * Generate container representation as JSON-LD
+ */
+
+const LDP = 'http://www.w3.org/ns/ldp#';
+
+/**
+ * Generate JSON-LD representation of a container
+ * @param {string} containerUrl - Full URL of the container
+ * @param {Array<{name: string, isDirectory: boolean}>} entries - Container contents
+ * @returns {object} - JSON-LD representation
+ */
+export function generateContainerJsonLd(containerUrl, entries) {
+  // Ensure container URL ends with /
+  const baseUrl = containerUrl.endsWith('/') ? containerUrl : containerUrl + '/';
+
+  const contains = entries.map(entry => {
+    const childUrl = baseUrl + entry.name + (entry.isDirectory ? '/' : '');
+    return {
+      '@id': childUrl,
+      '@type': entry.isDirectory ? [`${LDP}Container`, `${LDP}BasicContainer`, `${LDP}Resource`] : [`${LDP}Resource`]
+    };
+  });
+
+  return {
+    '@context': {
+      'ldp': LDP,
+      'contains': { '@id': 'ldp:contains', '@type': '@id' }
+    },
+    '@id': baseUrl,
+    '@type': ['ldp:Container', 'ldp:BasicContainer', 'ldp:Resource'],
+    'contains': contains
+  };
+}
+
+/**
+ * Convert JSON-LD to string
+ * @param {object} jsonLd
+ * @returns {string}
+ */
+export function serializeJsonLd(jsonLd) {
+  return JSON.stringify(jsonLd, null, 2);
+}

package/src/ldp/headers.js

@@ -0,0 +1,78 @@
+/**
+ * LDP (Linked Data Platform) header utilities
+ */
+
+const LDP = 'http://www.w3.org/ns/ldp#';
+
+/**
+ * Get Link headers for a resource
+ * @param {boolean} isContainer
+ * @returns {string}
+ */
+export function getLinkHeader(isContainer) {
+  const links = [`<${LDP}Resource>; rel="type"`];
+
+  if (isContainer) {
+    links.push(`<${LDP}Container>; rel="type"`);
+    links.push(`<${LDP}BasicContainer>; rel="type"`);
+  }
+
+  return links.join(', ');
+}
+
+/**
+ * Get standard LDP response headers
+ * @param {object} options
+ * @returns {object}
+ */
+export function getResponseHeaders({ isContainer = false, etag = null, contentType = null }) {
+  const headers = {
+    'Link': getLinkHeader(isContainer),
+    'WAC-Allow': 'user="read write append control", public="read write append"',
+    'Accept-Patch': 'application/sparql-update',
+    'Allow': 'GET, HEAD, PUT, DELETE, OPTIONS' + (isContainer ? ', POST' : ''),
+    'Vary': 'Accept, Authorization, Origin'
+  };
+
+  if (isContainer) {
+    headers['Accept-Post'] = '*/*';
+  }
+
+  if (etag) {
+    headers['ETag'] = etag;
+  }
+
+  if (contentType) {
+    headers['Content-Type'] = contentType;
+  }
+
+  return headers;
+}
+
+/**
+ * Get CORS headers
+ * @param {string} origin
+ * @returns {object}
+ */
+export function getCorsHeaders(origin) {
+  return {
+    'Access-Control-Allow-Origin': origin || '*',
+    'Access-Control-Allow-Methods': 'GET, HEAD, POST, PUT, DELETE, PATCH, OPTIONS',
+    'Access-Control-Allow-Headers': 'Accept, Authorization, Content-Type, If-Match, If-None-Match, Link, Slug, Origin',
+    'Access-Control-Expose-Headers': 'Accept-Patch, Accept-Post, Allow, Content-Type, ETag, Link, Location, WAC-Allow',
+    'Access-Control-Allow-Credentials': 'true',
+    'Access-Control-Max-Age': '86400'
+  };
+}
+
+/**
+ * Get all headers combined
+ * @param {object} options
+ * @returns {object}
+ */
+export function getAllHeaders({ isContainer = false, etag = null, contentType = null, origin = null }) {
+  return {
+    ...getResponseHeaders({ isContainer, etag, contentType }),
+    ...getCorsHeaders(origin)
+  };
+}

package/src/server.js

@@ -0,0 +1,68 @@
+import Fastify from 'fastify';
+import { handleGet, handleHead, handlePut, handleDelete, handleOptions } from './handlers/resource.js';
+import { handlePost, handleCreatePod } from './handlers/container.js';
+import { getCorsHeaders } from './ldp/headers.js';
+
+/**
+ * Create and configure Fastify server
+ */
+export function createServer(options = {}) {
+  const fastify = Fastify({
+    logger: options.logger ?? true,
+    trustProxy: true,
+    // Handle raw body for non-JSON content
+    bodyLimit: 10 * 1024 * 1024 // 10MB
+  });
+
+  // Add raw body parser for all content types
+  fastify.addContentTypeParser('*', { parseAs: 'buffer' }, (req, body, done) => {
+    done(null, body);
+  });
+
+  // Global CORS preflight
+  fastify.addHook('onRequest', async (request, reply) => {
+    // Add CORS headers to all responses
+    const corsHeaders = getCorsHeaders(request.headers.origin);
+    Object.entries(corsHeaders).forEach(([k, v]) => reply.header(k, v));
+
+    // Handle preflight
+    if (request.method === 'OPTIONS') {
+      reply.code(204).send();
+      return reply;
+    }
+  });
+
+  // Pod creation endpoint
+  fastify.post('/.pods', handleCreatePod);
+
+  // LDP routes - using wildcard routing
+  fastify.get('/*', handleGet);
+  fastify.head('/*', handleHead);
+  fastify.put('/*', handlePut);
+  fastify.delete('/*', handleDelete);
+  fastify.post('/*', handlePost);
+  fastify.options('/*', handleOptions);
+
+  // Root route
+  fastify.get('/', handleGet);
+  fastify.head('/', handleHead);
+  fastify.options('/', handleOptions);
+  fastify.post('/', handlePost);
+
+  return fastify;
+}
+
+/**
+ * Start the server
+ */
+export async function startServer(port = 3000, host = '0.0.0.0') {
+  const server = createServer();
+
+  try {
+    await server.listen({ port, host });
+    return server;
+  } catch (err) {
+    server.log.error(err);
+    process.exit(1);
+  }
+}

package/src/storage/filesystem.js

@@ -0,0 +1,151 @@
+import fs from 'fs-extra';
+import path from 'path';
+import crypto from 'crypto';
+import { DATA_ROOT, urlToPath, isContainer } from '../utils/url.js';
+
+// Ensure data directory exists
+fs.ensureDirSync(DATA_ROOT);
+
+/**
+ * Check if resource exists
+ * @param {string} urlPath
+ * @returns {Promise<boolean>}
+ */
+export async function exists(urlPath) {
+  const filePath = urlToPath(urlPath);
+  return fs.pathExists(filePath);
+}
+
+/**
+ * Get resource stats
+ * @param {string} urlPath
+ * @returns {Promise<{isDirectory: boolean, size: number, mtime: Date, etag: string} | null>}
+ */
+export async function stat(urlPath) {
+  const filePath = urlToPath(urlPath);
+
+  try {
+    const stats = await fs.stat(filePath);
+    return {
+      isDirectory: stats.isDirectory(),
+      size: stats.size,
+      mtime: stats.mtime,
+      etag: `"${crypto.createHash('md5').update(stats.mtime.toISOString() + stats.size).digest('hex')}"`
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Read resource content
+ * @param {string} urlPath
+ * @returns {Promise<Buffer | null>}
+ */
+export async function read(urlPath) {
+  const filePath = urlToPath(urlPath);
+
+  try {
+    return await fs.readFile(filePath);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Write resource content
+ * @param {string} urlPath
+ * @param {Buffer | string} content
+ * @returns {Promise<boolean>}
+ */
+export async function write(urlPath, content) {
+  const filePath = urlToPath(urlPath);
+
+  try {
+    // Ensure parent directory exists
+    await fs.ensureDir(path.dirname(filePath));
+    await fs.writeFile(filePath, content);
+    return true;
+  } catch (err) {
+    console.error('Write error:', err);
+    return false;
+  }
+}
+
+/**
+ * Delete resource
+ * @param {string} urlPath
+ * @returns {Promise<boolean>}
+ */
+export async function remove(urlPath) {
+  const filePath = urlToPath(urlPath);
+
+  try {
+    await fs.remove(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Create container (directory)
+ * @param {string} urlPath
+ * @returns {Promise<boolean>}
+ */
+export async function createContainer(urlPath) {
+  const filePath = urlToPath(urlPath);
+
+  try {
+    await fs.ensureDir(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * List container contents
+ * @param {string} urlPath
+ * @returns {Promise<Array<{name: string, isDirectory: boolean}> | null>}
+ */
+export async function listContainer(urlPath) {
+  const filePath = urlToPath(urlPath);
+
+  try {
+    const entries = await fs.readdir(filePath, { withFileTypes: true });
+    return entries.map(entry => ({
+      name: entry.name,
+      isDirectory: entry.isDirectory()
+    }));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Generate unique filename for POST
+ * @param {string} containerPath
+ * @param {string} slug
+ * @param {boolean} isDir
+ * @returns {Promise<string>}
+ */
+export async function generateUniqueFilename(containerPath, slug, isDir = false) {
+  const basePath = urlToPath(containerPath);
+  let name = slug || crypto.randomUUID();
+
+  // Remove any path traversal attempts
+  name = name.replace(/[/\\]/g, '-');
+
+  let candidate = path.join(basePath, name);
+  let counter = 1;
+
+  while (await fs.pathExists(candidate)) {
+    const ext = path.extname(name);
+    const base = path.basename(name, ext);
+    candidate = path.join(basePath, `${base}-${counter}${ext}`);
+    counter++;
+  }
+
+  return path.basename(candidate);
+}

package/src/utils/url.js

@@ -0,0 +1,83 @@
+import path from 'path';
+
+// Base directory for storing all pods
+export const DATA_ROOT = process.env.DATA_ROOT || './data';
+
+/**
+ * Convert URL path to filesystem path
+ * @param {string} urlPath - The URL path (e.g., /alice/profile/)
+ * @returns {string} - Filesystem path
+ */
+export function urlToPath(urlPath) {
+  // Normalize: remove leading slash, decode URI
+  let normalized = urlPath.startsWith('/') ? urlPath.slice(1) : urlPath;
+  normalized = decodeURIComponent(normalized);
+
+  // Security: prevent path traversal
+  normalized = normalized.replace(/\.\./g, '');
+
+  return path.join(DATA_ROOT, normalized);
+}
+
+/**
+ * Check if URL path represents a container (ends with /)
+ * @param {string} urlPath
+ * @returns {boolean}
+ */
+export function isContainer(urlPath) {
+  return urlPath.endsWith('/');
+}
+
+/**
+ * Get the parent container path
+ * @param {string} urlPath
+ * @returns {string}
+ */
+export function getParentContainer(urlPath) {
+  const parts = urlPath.replace(/\/$/, '').split('/');
+  parts.pop();
+  return parts.join('/') + '/';
+}
+
+/**
+ * Get resource name from URL path
+ * @param {string} urlPath
+ * @returns {string}
+ */
+export function getResourceName(urlPath) {
+  const parts = urlPath.replace(/\/$/, '').split('/');
+  return parts[parts.length - 1];
+}
+
+/**
+ * Determine content type from file extension
+ * @param {string} filePath
+ * @returns {string}
+ */
+export function getContentType(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  const types = {
+    '.jsonld': 'application/ld+json',
+    '.json': 'application/json',
+    '.html': 'text/html',
+    '.txt': 'text/plain',
+    '.css': 'text/css',
+    '.js': 'application/javascript',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.svg': 'image/svg+xml',
+    '.pdf': 'application/pdf'
+  };
+  return types[ext] || 'application/octet-stream';
+}
+
+/**
+ * Check if content type is RDF
+ * @param {string} contentType
+ * @returns {boolean}
+ */
+export function isRdfContentType(contentType) {
+  return contentType === 'application/ld+json' || contentType === 'application/json';
+}