javascript-solid-server 0.0.28 → 0.0.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "javascript-solid-server",
-  "version": "0.0.28",
+  "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);
-
-      Object.entries(headers).forEach(([k, v]) => reply.header(k, v));
-      return reply.send(outputContent);
-    } catch (e) {
-      // If not valid JSON-LD, serve as-is
+  // 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
+      }
     }
   }
 
@@ -495,20 +527,129 @@ export async function handlePatch(request, reply) {
 
   // Read existing content or start with empty JSON-LD document
   let document;
+  let htmlWrapper = null; // Track HTML wrapper for data island re-embedding
+
   if (resourceExists) {
     const existingContent = await storage.read(storagePath);
     if (existingContent === null) {
       return reply.code(500).send({ error: 'Read error' });
     }
 
-    // Parse existing document as JSON-LD
-    try {
-      document = JSON.parse(existingContent.toString());
-    } catch (e) {
-      return reply.code(409).send({
-        error: 'Conflict',
-        message: 'Resource is not valid JSON-LD and cannot be patched'
-      });
+    const contentStr = existingContent.toString();
+
+    // Check if this is HTML with embedded JSON-LD data island
+    if (contentStr.trimStart().startsWith('<!DOCTYPE') || contentStr.trimStart().startsWith('<html')) {
+      // Extract JSON-LD from <script type="application/ld+json"> tag
+      const jsonLdMatch = contentStr.match(/<script\s+type=["']application\/ld\+json["']\s*>([\s\S]*?)<\/script>/i);
+
+      if (!jsonLdMatch) {
+        return reply.code(409).send({
+          error: 'Conflict',
+          message: 'HTML document does not contain a JSON-LD data island'
+        });
+      }
+
+      try {
+        document = JSON.parse(jsonLdMatch[1]);
+        // Save the HTML parts for re-embedding after patch
+        const jsonLdStart = contentStr.indexOf(jsonLdMatch[0]) + jsonLdMatch[0].indexOf('>') + 1;
+        const jsonLdEnd = jsonLdStart + jsonLdMatch[1].length;
+        htmlWrapper = {
+          before: contentStr.substring(0, jsonLdStart),
+          after: contentStr.substring(jsonLdEnd)
+        };
+      } catch (e) {
+        return reply.code(409).send({
+          error: 'Conflict',
+          message: 'HTML data island contains invalid JSON-LD'
+        });
+      }
+    } else {
+      // 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'
+        });
+      }
     }
   } else {
     // Create empty JSON-LD document for new resource
@@ -568,7 +709,14 @@ export async function handlePatch(request, reply) {
   }
 
   // Write updated document
-  const updatedContent = JSON.stringify(updatedDocument, null, 2);
+  let updatedContent;
+  if (htmlWrapper) {
+    // Re-embed JSON-LD into HTML wrapper
+    const jsonLdStr = JSON.stringify(updatedDocument, null, 2);
+    updatedContent = htmlWrapper.before + '\n' + jsonLdStr + '\n  ' + htmlWrapper.after;
+  } else {
+    updatedContent = JSON.stringify(updatedDocument, null, 2);
+  }
   const success = await storage.write(storagePath, Buffer.from(updatedContent));
 
   if (!success) {

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,40 +33,32 @@ 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`
   };
 }
 
 /**
- * Generate HTML profile with embedded JSON-LD
+ * Generate HTML profile with embedded JSON-LD data island
+ * The page uses mashlib + solidos-lite to render the profile from the data island
  * @param {object} options
  * @param {string} options.webId - Full WebID URI
  * @param {string} options.name - Display name
  * @param {string} options.podUri - Pod root URI
  * @param {string} options.issuer - OIDC issuer URI
- * @returns {string} HTML document with JSON-LD
+ * @returns {string} HTML document with JSON-LD data island
  */
 export function generateProfile({ webId, name, podUri, issuer }) {
   const jsonLd = generateProfileJsonLd({ webId, name, podUri, issuer });
-  const pod = podUri.endsWith('/') ? podUri : podUri + '/';
 
   return `<!DOCTYPE html>
 <html lang="en">
@@ -74,30 +66,52 @@ export function generateProfile({ webId, name, podUri, issuer }) {
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width, initial-scale=1">
   <title>${escapeHtml(name)}'s Profile</title>
+  <link rel="stylesheet" href="https://javascriptsolidserver.github.io/mashlib-jss/dist/mash.css">
   <script type="application/ld+json">
 ${JSON.stringify(jsonLd, null, 2)}
   </script>
   <style>
-    body { font-family: system-ui, sans-serif; max-width: 600px; margin: 2rem auto; padding: 0 1rem; }
-    h1 { color: #333; }
-    .card { background: #f5f5f5; padding: 1.5rem; border-radius: 8px; }
-    dt { font-weight: bold; margin-top: 1rem; }
-    dd { margin-left: 0; color: #666; }
-    a { color: #7c4dff; }
+    body { margin: 0; font-family: system-ui, sans-serif; }
+    .loading { padding: 2rem; text-align: center; color: #666; }
   </style>
 </head>
 <body>
-  <div class="card">
-    <h1>${escapeHtml(name)}</h1>
-    <dl>
-      <dt>WebID</dt>
-      <dd><a href="${escapeHtml(webId)}">${escapeHtml(webId)}</a></dd>
-      <dt>Storage</dt>
-      <dd><a href="${escapeHtml(pod)}">${escapeHtml(pod)}</a></dd>
-      <dt>Inbox</dt>
-      <dd><a href="${escapeHtml(pod)}inbox/">${escapeHtml(pod)}inbox/</a></dd>
-    </dl>
+  <div class="TabulatorOutline" id="DummyUUID" role="main">
+    <table id="outline"></table>
+    <div id="GlobalDashboard"></div>
   </div>
+  <div class="loading" id="loading">Loading profile...</div>
+
+  <script src="https://javascriptsolidserver.github.io/mashlib-jss/dist/mashlib.min.js"></script>
+  <script src="https://cdn.jsdelivr.net/npm/solidos-lite/solidos-lite.js"></script>
+  <script>
+  document.addEventListener('DOMContentLoaded', function() {
+    const loadingEl = document.getElementById('loading');
+
+    // Initialize solidos-lite to handle data islands
+    const success = SolidOSLite.init({ verbose: false });
+    if (!success) {
+      loadingEl.textContent = 'Failed to initialize. Please try refreshing.';
+      return;
+    }
+
+    // Parse data islands into the RDF store
+    SolidOSLite.parseAllIslands();
+
+    // Mark this document as already fetched
+    const pageBase = window.location.href.split('?')[0].split('#')[0];
+    const fetcher = SolidLogic.store.fetcher;
+    fetcher.requested[pageBase] = 'done';
+    fetcher.requested[pageBase.replace(/\\/$/, '')] = 'done';
+
+    // Navigate to #me
+    const subject = $rdf.sym(pageBase + '#me');
+    const outliner = panes.getOutliner(document);
+    outliner.GotoSubject(subject, true, undefined, true, undefined);
+
+    loadingEl.style.display = 'none';
+  });
+  </script>
 </body>
 </html>`;
 }