javascript-solid-server 0.0.29 → 0.0.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "javascript-solid-server",
-  "version": "0.0.29",
+  "version": "0.0.31",
   "description": "A minimal, fast Solid server",
   "main": "src/index.js",
   "type": "module",

package/src/handlers/resource.js

@@ -192,38 +192,70 @@ export async function handleGet(request, reply) {
     return reply.code(500).send({ error: 'Read error' });
   }
 
-  // Content negotiation for RDF resources
-  if (connegEnabled && isRdfContentType(storedContentType)) {
-    try {
-      // Parse stored content as JSON-LD
-      const jsonLd = JSON.parse(content.toString());
-
-      // Select output format based on Accept header
-      const acceptHeader = request.headers.accept;
-      const targetType = selectContentType(acceptHeader, connegEnabled);
-
-      // Convert to requested format
-      const { content: outputContent, contentType: outputType } = await fromJsonLd(
-        jsonLd,
-        targetType,
-        resourceUrl,
-        connegEnabled
-      );
-
-      const headers = getAllHeaders({
-        isContainer: false,
-        etag: stats.etag,
-        contentType: outputType,
-        origin,
-        resourceUrl,
-        connegEnabled
-      });
-      headers['Vary'] = getVaryHeader(connegEnabled, request.mashlibEnabled);
+  // Content negotiation for RDF resources (including HTML with JSON-LD data islands)
+  if (connegEnabled) {
+    const contentStr = content.toString();
+    const acceptHeader = request.headers.accept || '';
+    const wantsTurtle = acceptHeader.includes('text/turtle') ||
+                        acceptHeader.includes('text/n3') ||
+                        acceptHeader.includes('application/n-triples');
+
+    // Check if this is HTML with JSON-LD data island
+    const isHtmlWithDataIsland = contentStr.trimStart().startsWith('<!DOCTYPE') ||
+                                  contentStr.trimStart().startsWith('<html');
+
+    if (isHtmlWithDataIsland && wantsTurtle) {
+      // Extract JSON-LD from HTML data island and convert to Turtle
+      try {
+        const jsonLdMatch = contentStr.match(/<script\s+type=["']application\/ld\+json["']\s*>([\s\S]*?)<\/script>/i);
+        if (jsonLdMatch) {
+          const jsonLd = JSON.parse(jsonLdMatch[1]);
+          const { content: turtleContent } = await fromJsonLd(jsonLd, 'text/turtle', resourceUrl, true);
+
+          const headers = getAllHeaders({
+            isContainer: false,
+            etag: stats.etag,
+            contentType: 'text/turtle',
+            origin,
+            resourceUrl,
+            connegEnabled
+          });
+          headers['Vary'] = getVaryHeader(connegEnabled, request.mashlibEnabled);
+
+          Object.entries(headers).forEach(([k, v]) => reply.header(k, v));
+          return reply.send(turtleContent);
+        }
+      } catch (err) {
+        // Fall through to serve HTML if conversion fails
+        console.error('Failed to convert HTML data island to Turtle:', err.message);
+      }
+    } else if (isRdfContentType(storedContentType)) {
+      // Plain JSON-LD file
+      try {
+        const jsonLd = JSON.parse(contentStr);
+        const targetType = selectContentType(acceptHeader, connegEnabled);
+        const { content: outputContent, contentType: outputType } = await fromJsonLd(
+          jsonLd,
+          targetType,
+          resourceUrl,
+          connegEnabled
+        );
+
+        const headers = getAllHeaders({
+          isContainer: false,
+          etag: stats.etag,
+          contentType: outputType,
+          origin,
+          resourceUrl,
+          connegEnabled
+        });
+        headers['Vary'] = getVaryHeader(connegEnabled, request.mashlibEnabled);
 
-      Object.entries(headers).forEach(([k, v]) => reply.header(k, v));
-      return reply.send(outputContent);
-    } catch (e) {
-      // If not valid JSON-LD, serve as-is
+        Object.entries(headers).forEach(([k, v]) => reply.header(k, v));
+        return reply.send(outputContent);
+      } catch (e) {
+        // If not valid JSON-LD, serve as-is
+      }
     }
   }
 
@@ -533,10 +565,86 @@ export async function handlePatch(request, reply) {
         });
       }
     } else {
-      // Parse as plain JSON-LD
+      // Try to parse as JSON-LD first
       try {
         document = JSON.parse(contentStr);
       } catch (e) {
+        // Not JSON - might be Turtle, handle with RDF store for SPARQL Update
+        if (isSparqlUpdate) {
+          // Parse Turtle and apply SPARQL Update directly
+          const { Parser, Writer } = await import('n3');
+          const parser = new Parser({ baseIRI: resourceUrl });
+          let quads;
+          try {
+            quads = parser.parse(contentStr);
+          } catch (parseErr) {
+            return reply.code(409).send({
+              error: 'Conflict',
+              message: 'Resource is not valid Turtle: ' + parseErr.message
+            });
+          }
+
+          // Parse the SPARQL Update
+          const patchContent = Buffer.isBuffer(request.body) ? request.body.toString() : request.body;
+          let update;
+          try {
+            update = parseSparqlUpdate(patchContent, resourceUrl);
+          } catch (parseErr) {
+            return reply.code(400).send({
+              error: 'Bad Request',
+              message: 'Invalid SPARQL Update: ' + parseErr.message
+            });
+          }
+
+          // Apply deletes
+          for (const triple of update.deletes) {
+            quads = quads.filter(q => {
+              const matches = q.subject.value === triple.subject &&
+                             q.predicate.value === triple.predicate &&
+                             (q.object.value === (triple.object['@id'] || triple.object['@value'] || triple.object));
+              return !matches;
+            });
+          }
+
+          // Apply inserts
+          const { DataFactory } = await import('n3');
+          const { namedNode, literal } = DataFactory;
+          for (const triple of update.inserts) {
+            const subj = namedNode(triple.subject);
+            const pred = namedNode(triple.predicate);
+            let obj;
+            if (triple.object['@id']) {
+              obj = namedNode(triple.object['@id']);
+            } else if (typeof triple.object === 'string') {
+              obj = literal(triple.object);
+            } else {
+              obj = literal(triple.object['@value'] || triple.object);
+            }
+            quads.push(DataFactory.quad(subj, pred, obj));
+          }
+
+          // Serialize back to Turtle
+          const writer = new Writer({ prefixes: {} });
+          quads.forEach(q => writer.addQuad(q));
+          let turtleOutput;
+          writer.end((err, result) => { turtleOutput = result; });
+
+          const success = await storage.write(storagePath, Buffer.from(turtleOutput));
+          if (!success) {
+            return reply.code(500).send({ error: 'Write failed' });
+          }
+
+          const origin = request.headers.origin;
+          const headers = getAllHeaders({ isContainer: false, origin, resourceUrl });
+          Object.entries(headers).forEach(([k, v]) => reply.header(k, v));
+
+          if (request.notificationsEnabled) {
+            emitChange(resourceUrl);
+          }
+
+          return reply.code(resourceExists ? 204 : 201).send();
+        }
+
         return reply.code(409).send({
           error: 'Conflict',
           message: 'Resource is not valid JSON-LD and cannot be patched'

package/src/rdf/turtle.js

@@ -151,14 +151,15 @@ function quadsToJsonLd(quads, baseUri, prefixes = {}) {
     nodes.push(jsonNode);
   }
 
-  // Build result
+  // Build result - return array if multiple nodes, single object otherwise
   const context = buildContext(prefixes);
 
   if (nodes.length === 1) {
     return { '@context': context, ...nodes[0] };
   }
 
-  return { '@context': context, '@graph': nodes };
+  // Multiple nodes: return as array (no @graph)
+  return nodes.map((node, i) => i === 0 ? { '@context': context, ...node } : node);
 }
 
 /**
@@ -166,10 +167,25 @@ function quadsToJsonLd(quads, baseUri, prefixes = {}) {
  */
 function jsonLdToQuads(jsonLd, baseUri) {
   const quads = [];
-  const context = jsonLd['@context'] || {};
 
-  // Handle @graph or single object
-  const nodes = jsonLd['@graph'] || [jsonLd];
+  // Handle array of JSON-LD objects (e.g., from multiple PATCH operations)
+  const documents = Array.isArray(jsonLd) ? jsonLd : [jsonLd];
+
+  // Merge all contexts and collect all nodes
+  let mergedContext = {};
+  let nodes = [];
+
+  for (const doc of documents) {
+    if (doc['@context']) {
+      mergedContext = { ...mergedContext, ...doc['@context'] };
+    }
+    // Each document with @id is a node (no @graph needed)
+    if (doc['@id']) {
+      nodes.push(doc);
+    }
+  }
+
+  const context = mergedContext;
 
   for (const node of nodes) {
     if (!node['@id']) continue;

package/src/webid/profile.js

@@ -33,25 +33,17 @@ export function generateProfileJsonLd({ webId, name, podUri, issuer }) {
       'inbox': { '@id': 'ldp:inbox', '@type': '@id' },
       'storage': { '@id': 'pim:storage', '@type': '@id' },
       'oidcIssuer': { '@id': 'solid:oidcIssuer', '@type': '@id' },
-      'preferencesFile': { '@id': 'pim:preferencesFile', '@type': '@id' }
+      'preferencesFile': { '@id': 'pim:preferencesFile', '@type': '@id' },
+      'mainEntityOfPage': { '@id': 'schema:mainEntityOfPage', '@type': '@id' }
     },
-    '@graph': [
-      {
-        '@id': profileDoc,
-        '@type': 'foaf:PersonalProfileDocument',
-        'foaf:maker': { '@id': webId },
-        'foaf:primaryTopic': { '@id': webId }
-      },
-      {
-        '@id': webId,
-        '@type': ['foaf:Person', 'schema:Person'],
-        'foaf:name': name,
-        'inbox': `${pod}inbox/`,
-        'storage': pod,
-        'oidcIssuer': issuer,
-        'preferencesFile': `${pod}settings/prefs`
-      }
-    ]
+    '@id': webId,
+    '@type': ['foaf:Person', 'schema:Person'],
+    'foaf:name': name,
+    'mainEntityOfPage': profileDoc,
+    'inbox': `${pod}inbox/`,
+    'storage': pod,
+    'oidcIssuer': issuer,
+    'preferencesFile': `${pod}settings/prefs`
   };
 }