javascript-solid-server 0.0.6 → 0.0.7

package/package.json

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

package/src/handlers/resource.js

@@ -2,6 +2,7 @@ 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';
+import { parseN3Patch, applyN3Patch, validatePatch } from '../patch/n3-patch.js';
 
 /**
  * Handle GET request
@@ -190,3 +191,99 @@ export async function handleOptions(request, reply) {
   Object.entries(headers).forEach(([k, v]) => reply.header(k, v));
   return reply.code(204).send();
 }
+
+/**
+ * Handle PATCH request
+ * Supports N3 Patch format (text/n3) for updating RDF resources
+ */
+export async function handlePatch(request, reply) {
+  const urlPath = request.url.split('?')[0];
+
+  // Don't allow PATCH to containers
+  if (isContainer(urlPath)) {
+    return reply.code(409).send({ error: 'Cannot PATCH containers' });
+  }
+
+  // Check content type
+  const contentType = request.headers['content-type'] || '';
+  const isN3Patch = contentType.includes('text/n3') ||
+                    contentType.includes('application/n3') ||
+                    contentType.includes('application/sparql-update');
+
+  if (!isN3Patch) {
+    return reply.code(415).send({
+      error: 'Unsupported Media Type',
+      message: 'PATCH requires Content-Type: text/n3 for N3 Patch format'
+    });
+  }
+
+  // Check if resource exists
+  const stats = await storage.stat(urlPath);
+  if (!stats) {
+    return reply.code(404).send({ error: 'Not Found' });
+  }
+
+  // Read existing content
+  const existingContent = await storage.read(urlPath);
+  if (existingContent === null) {
+    return reply.code(500).send({ error: 'Read error' });
+  }
+
+  // Parse existing document as JSON-LD
+  let document;
+  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'
+    });
+  }
+
+  // Parse the patch
+  const patchContent = Buffer.isBuffer(request.body)
+    ? request.body.toString()
+    : 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
+    });
+  }
+
+  // Write updated document
+  const updatedContent = JSON.stringify(updatedDocument, null, 2);
+  const success = await storage.write(urlPath, Buffer.from(updatedContent));
+
+  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));
+
+  return reply.code(204).send();
+}

package/src/patch/n3-patch.js

@@ -0,0 +1,522 @@
+/**
+ * N3 Patch Parser and Applier
+ *
+ * Implements Solid's N3 Patch format for updating RDF resources.
+ * https://solid.github.io/specification/protocol#n3-patch
+ *
+ * Supported format:
+ * @prefix solid: <http://www.w3.org/ns/solid/terms#>.
+ * _:patch a solid:InsertDeletePatch;
+ *   solid:inserts { <subject> <predicate> "object" };
+ *   solid:deletes { <subject> <predicate> "old" }.
+ */
+
+const SOLID_NS = 'http://www.w3.org/ns/solid/terms#';
+
+/**
+ * Parse an N3 Patch document
+ * @param {string} patchText - The N3 patch content
+ * @param {string} baseUri - Base URI for resolving relative references
+ * @returns {{inserts: Array, deletes: Array, where: Array}}
+ */
+export function parseN3Patch(patchText, baseUri) {
+  const result = {
+    inserts: [],
+    deletes: [],
+    where: []
+  };
+
+  // Extract prefixes
+  const prefixes = {};
+  const prefixRegex = /@prefix\s+(\w*):?\s*<([^>]+)>\s*\./g;
+  let match;
+  while ((match = prefixRegex.exec(patchText)) !== null) {
+    prefixes[match[1]] = match[2];
+  }
+
+  // Find solid:inserts block
+  const insertsMatch = patchText.match(/solid:inserts\s*\{([^}]*)\}/s);
+  if (insertsMatch) {
+    result.inserts = parseTriples(insertsMatch[1], prefixes, baseUri);
+  }
+
+  // Find solid:deletes block
+  const deletesMatch = patchText.match(/solid:deletes\s*\{([^}]*)\}/s);
+  if (deletesMatch) {
+    result.deletes = parseTriples(deletesMatch[1], prefixes, baseUri);
+  }
+
+  // Find solid:where block (for conditions - simplified support)
+  const whereMatch = patchText.match(/solid:where\s*\{([^}]*)\}/s);
+  if (whereMatch) {
+    result.where = parseTriples(whereMatch[1], prefixes, baseUri);
+  }
+
+  return result;
+}
+
+/**
+ * Parse triples from N3 block content
+ */
+function parseTriples(content, prefixes, baseUri) {
+  const triples = [];
+
+  // Clean up content
+  content = content.trim();
+  if (!content) return triples;
+
+  // Split by '.' but be careful with strings containing '.'
+  const statements = splitStatements(content);
+
+  for (const stmt of statements) {
+    const triple = parseStatement(stmt.trim(), prefixes, baseUri);
+    if (triple) {
+      triples.push(triple);
+    }
+  }
+
+  return triples;
+}
+
+/**
+ * Split content into statements (handling quoted strings)
+ */
+function splitStatements(content) {
+  const statements = [];
+  let current = '';
+  let inString = false;
+  let stringChar = null;
+
+  for (let i = 0; i < content.length; i++) {
+    const char = content[i];
+
+    if (!inString && (char === '"' || char === "'")) {
+      inString = true;
+      stringChar = char;
+      current += char;
+    } else if (inString && char === stringChar && content[i - 1] !== '\\') {
+      inString = false;
+      stringChar = null;
+      current += char;
+    } else if (!inString && char === '.') {
+      if (current.trim()) {
+        statements.push(current);
+      }
+      current = '';
+    } else if (!inString && char === ';') {
+      // Turtle shorthand - same subject, different predicate
+      if (current.trim()) {
+        statements.push(current);
+      }
+      current = '';
+    } else {
+      current += char;
+    }
+  }
+
+  if (current.trim()) {
+    statements.push(current);
+  }
+
+  return statements;
+}
+
+/**
+ * Parse a single N3 statement into a triple
+ */
+function parseStatement(stmt, prefixes, baseUri) {
+  if (!stmt) return null;
+
+  // Tokenize - split by whitespace but respect quotes
+  const tokens = tokenize(stmt);
+  if (tokens.length < 3) return null;
+
+  const subject = resolveValue(tokens[0], prefixes, baseUri);
+  const predicate = resolveValue(tokens[1], prefixes, baseUri);
+  const object = resolveValue(tokens.slice(2).join(' '), prefixes, baseUri);
+
+  return { subject, predicate, object };
+}
+
+/**
+ * Tokenize a statement respecting quoted strings
+ */
+function tokenize(stmt) {
+  const tokens = [];
+  let current = '';
+  let inString = false;
+  let stringChar = null;
+
+  for (let i = 0; i < stmt.length; i++) {
+    const char = stmt[i];
+
+    if (!inString && (char === '"' || char === "'")) {
+      inString = true;
+      stringChar = char;
+      current += char;
+    } else if (inString && char === stringChar && stmt[i - 1] !== '\\') {
+      inString = false;
+      stringChar = null;
+      current += char;
+    } else if (!inString && /\s/.test(char)) {
+      if (current) {
+        tokens.push(current);
+        current = '';
+      }
+    } else {
+      current += char;
+    }
+  }
+
+  if (current) {
+    tokens.push(current);
+  }
+
+  return tokens;
+}
+
+/**
+ * Resolve a value (URI, prefixed name, or literal)
+ */
+function resolveValue(value, prefixes, baseUri) {
+  value = value.trim();
+
+  // Full URI
+  if (value.startsWith('<') && value.endsWith('>')) {
+    const uri = value.slice(1, -1);
+    // Resolve relative URIs
+    if (!uri.includes('://') && !uri.startsWith('#')) {
+      return new URL(uri, baseUri).href;
+    }
+    if (uri.startsWith('#')) {
+      return baseUri + uri;
+    }
+    return uri;
+  }
+
+  // Prefixed name
+  if (value.includes(':') && !value.startsWith('"')) {
+    const [prefix, local] = value.split(':', 2);
+    if (prefixes[prefix]) {
+      return prefixes[prefix] + local;
+    }
+    // Common prefixes
+    const commonPrefixes = {
+      'solid': SOLID_NS,
+      'rdf': 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
+      'rdfs': 'http://www.w3.org/2000/01/rdf-schema#',
+      'foaf': 'http://xmlns.com/foaf/0.1/',
+      'dc': 'http://purl.org/dc/terms/',
+      'schema': 'http://schema.org/',
+      'ldp': 'http://www.w3.org/ns/ldp#'
+    };
+    if (commonPrefixes[prefix]) {
+      return commonPrefixes[prefix] + local;
+    }
+  }
+
+  // String literal
+  if (value.startsWith('"')) {
+    // Handle typed literals "value"^^<type>
+    const typedMatch = value.match(/^"(.*)"\^\^<([^>]+)>$/);
+    if (typedMatch) {
+      return { value: typedMatch[1], type: typedMatch[2] };
+    }
+    // Handle language tags "value"@en
+    const langMatch = value.match(/^"(.*)"@(\w+)$/);
+    if (langMatch) {
+      return { value: langMatch[1], language: langMatch[2] };
+    }
+    // Plain string
+    const plainMatch = value.match(/^"(.*)"$/);
+    if (plainMatch) {
+      return plainMatch[1];
+    }
+  }
+
+  // Variable (for WHERE patterns)
+  if (value.startsWith('?')) {
+    return { variable: value.slice(1) };
+  }
+
+  // Blank node
+  if (value.startsWith('_:')) {
+    return { blankNode: value.slice(2) };
+  }
+
+  return value;
+}
+
+/**
+ * Apply an N3 Patch to a JSON-LD document
+ * @param {object} document - The JSON-LD document
+ * @param {object} patch - Parsed patch {inserts, deletes}
+ * @param {string} baseUri - Base URI of the document
+ * @returns {object} Updated JSON-LD document
+ */
+export function applyN3Patch(document, patch, baseUri) {
+  // Clone the document
+  let doc = JSON.parse(JSON.stringify(document));
+
+  // Handle @graph array or single object
+  const isGraph = Array.isArray(doc['@graph']);
+  let nodes = isGraph ? doc['@graph'] : [doc];
+
+  // Apply deletes first
+  for (const triple of patch.deletes) {
+    nodes = deleteTriple(nodes, triple, baseUri);
+  }
+
+  // Then apply inserts
+  for (const triple of patch.inserts) {
+    nodes = insertTriple(nodes, triple, baseUri);
+  }
+
+  // Reconstruct document
+  if (isGraph) {
+    doc['@graph'] = nodes;
+  } else {
+    doc = nodes[0] || doc;
+  }
+
+  return doc;
+}
+
+/**
+ * Delete a triple from JSON-LD nodes
+ */
+function deleteTriple(nodes, triple, baseUri) {
+  const { subject, predicate, object } = triple;
+
+  for (const node of nodes) {
+    const nodeId = node['@id'] || '';
+    const resolvedNodeId = nodeId.startsWith('#') ? baseUri + nodeId : nodeId;
+
+    // Check if this node matches the subject
+    if (resolvedNodeId === subject || nodeId === subject) {
+      // Find the predicate
+      for (const key of Object.keys(node)) {
+        if (key.startsWith('@')) continue;
+
+        // Check if key matches predicate (could be full URI or prefixed)
+        if (key === predicate || expandPredicate(key) === predicate) {
+          const values = Array.isArray(node[key]) ? node[key] : [node[key]];
+          const newValues = values.filter(v => !valueMatches(v, object));
+
+          if (newValues.length === 0) {
+            delete node[key];
+          } else if (newValues.length === 1) {
+            node[key] = newValues[0];
+          } else {
+            node[key] = newValues;
+          }
+        }
+      }
+    }
+  }
+
+  return nodes;
+}
+
+/**
+ * Insert a triple into JSON-LD nodes
+ */
+function insertTriple(nodes, triple, baseUri) {
+  const { subject, predicate, object } = triple;
+
+  // Find or create the subject node
+  let subjectNode = nodes.find(n => {
+    const nodeId = n['@id'] || '';
+    const resolvedNodeId = nodeId.startsWith('#') ? baseUri + nodeId : nodeId;
+    return resolvedNodeId === subject || nodeId === subject;
+  });
+
+  if (!subjectNode) {
+    // Create new node
+    subjectNode = { '@id': subject };
+    nodes.push(subjectNode);
+  }
+
+  // Add the predicate-object
+  const predicateKey = compactPredicate(predicate);
+  const objectValue = convertToJsonLd(object);
+
+  if (subjectNode[predicateKey]) {
+    // Add to existing values
+    const existing = Array.isArray(subjectNode[predicateKey])
+      ? subjectNode[predicateKey]
+      : [subjectNode[predicateKey]];
+
+    // Check if value already exists
+    if (!existing.some(v => valueMatches(v, object))) {
+      subjectNode[predicateKey] = [...existing, objectValue];
+    }
+  } else {
+    subjectNode[predicateKey] = objectValue;
+  }
+
+  return nodes;
+}
+
+/**
+ * Check if a JSON-LD value matches an N3 object
+ */
+function valueMatches(jsonLdValue, n3Object) {
+  // Handle null/undefined
+  if (jsonLdValue === null || jsonLdValue === undefined) {
+    return false;
+  }
+
+  // Number comparison - N3 numbers may come as strings
+  if (typeof jsonLdValue === 'number') {
+    if (typeof n3Object === 'number') {
+      return jsonLdValue === n3Object;
+    }
+    if (typeof n3Object === 'string') {
+      return jsonLdValue === parseFloat(n3Object) || jsonLdValue.toString() === n3Object;
+    }
+  }
+
+  // String comparison
+  if (typeof jsonLdValue === 'string' && typeof n3Object === 'string') {
+    return jsonLdValue === n3Object;
+  }
+
+  // @id comparison
+  if (jsonLdValue && jsonLdValue['@id']) {
+    return jsonLdValue['@id'] === n3Object;
+  }
+
+  // @value comparison
+  if (jsonLdValue && jsonLdValue['@value']) {
+    if (typeof n3Object === 'object' && n3Object.value) {
+      return jsonLdValue['@value'] === n3Object.value;
+    }
+    return jsonLdValue['@value'] === n3Object;
+  }
+
+  // Direct equality (for booleans, numbers parsed as numbers, etc.)
+  return jsonLdValue === n3Object || String(jsonLdValue) === String(n3Object);
+}
+
+/**
+ * Convert N3 object to JSON-LD value
+ */
+function convertToJsonLd(object) {
+  if (typeof object === 'string') {
+    // Check if it's a URI
+    if (object.startsWith('http://') || object.startsWith('https://')) {
+      return { '@id': object };
+    }
+    return object;
+  }
+
+  if (typeof object === 'object') {
+    if (object.value && object.type) {
+      return { '@value': object.value, '@type': object.type };
+    }
+    if (object.value && object.language) {
+      return { '@value': object.value, '@language': object.language };
+    }
+    if (object.value) {
+      return object.value;
+    }
+  }
+
+  return object;
+}
+
+/**
+ * Expand a potentially prefixed predicate to full URI
+ */
+function expandPredicate(predicate) {
+  const commonPrefixes = {
+    'solid': SOLID_NS,
+    'rdf': 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
+    'rdfs': 'http://www.w3.org/2000/01/rdf-schema#',
+    'foaf': 'http://xmlns.com/foaf/0.1/',
+    'dc': 'http://purl.org/dc/terms/',
+    'schema': 'http://schema.org/',
+    'ldp': 'http://www.w3.org/ns/ldp#'
+  };
+
+  if (predicate.includes(':')) {
+    const [prefix, local] = predicate.split(':', 2);
+    if (commonPrefixes[prefix]) {
+      return commonPrefixes[prefix] + local;
+    }
+  }
+
+  return predicate;
+}
+
+/**
+ * Compact a full URI predicate to prefixed form if possible
+ */
+function compactPredicate(predicate) {
+  const prefixMap = {
+    [SOLID_NS]: 'solid:',
+    'http://www.w3.org/1999/02/22-rdf-syntax-ns#': 'rdf:',
+    'http://www.w3.org/2000/01/rdf-schema#': 'rdfs:',
+    'http://xmlns.com/foaf/0.1/': 'foaf:',
+    'http://purl.org/dc/terms/': 'dc:',
+    'http://schema.org/': 'schema:',
+    'http://www.w3.org/ns/ldp#': 'ldp:'
+  };
+
+  for (const [uri, prefix] of Object.entries(prefixMap)) {
+    if (predicate.startsWith(uri)) {
+      return prefix + predicate.slice(uri.length);
+    }
+  }
+
+  return predicate;
+}
+
+/**
+ * Validate that a patch can be applied
+ * @param {object} document - The JSON-LD document
+ * @param {object} patch - Parsed patch
+ * @param {string} baseUri - Base URI
+ * @returns {{valid: boolean, error: string|null}}
+ */
+export function validatePatch(document, patch, baseUri) {
+  // Check that all deletes exist in the document
+  for (const triple of patch.deletes) {
+    if (!tripleExists(document, triple, baseUri)) {
+      return {
+        valid: false,
+        error: `Triple to delete not found: ${JSON.stringify(triple)}`
+      };
+    }
+  }
+
+  return { valid: true, error: null };
+}
+
+/**
+ * Check if a triple exists in a document
+ */
+function tripleExists(document, triple, baseUri) {
+  const nodes = document['@graph'] || [document];
+  const { subject, predicate, object } = triple;
+
+  for (const node of nodes) {
+    const nodeId = node['@id'] || '';
+    const resolvedNodeId = nodeId.startsWith('#') ? baseUri + nodeId : nodeId;
+
+    if (resolvedNodeId === subject || nodeId === subject) {
+      for (const key of Object.keys(node)) {
+        if (key.startsWith('@')) continue;
+        if (key === predicate || expandPredicate(key) === predicate) {
+          const values = Array.isArray(node[key]) ? node[key] : [node[key]];
+          if (values.some(v => valueMatches(v, object))) {
+            return true;
+          }
+        }
+      }
+    }
+  }
+
+  return false;
+}

package/src/server.js

@@ -1,5 +1,5 @@
 import Fastify from 'fastify';
-import { handleGet, handleHead, handlePut, handleDelete, handleOptions } from './handlers/resource.js';
+import { handleGet, handleHead, handlePut, handleDelete, handleOptions, handlePatch } from './handlers/resource.js';
 import { handlePost, handleCreatePod } from './handlers/container.js';
 import { getCorsHeaders } from './ldp/headers.js';
 import { authorize, handleUnauthorized } from './auth/middleware.js';
@@ -63,6 +63,7 @@ export function createServer(options = {}) {
   fastify.put('/*', handlePut);
   fastify.delete('/*', handleDelete);
   fastify.post('/*', handlePost);
+  fastify.patch('/*', handlePatch);
   fastify.options('/*', handleOptions);
 
   // Root route

package/test/patch.test.js

@@ -0,0 +1,295 @@
+/**
+ * PATCH (N3 Patch) tests
+ */
+
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert';
+import {
+  startTestServer,
+  stopTestServer,
+  request,
+  createTestPod,
+  getBaseUrl,
+  assertStatus,
+  assertHeader
+} from './helpers.js';
+
+describe('PATCH Operations', () => {
+  before(async () => {
+    await startTestServer();
+    await createTestPod('patchtest');
+  });
+
+  after(async () => {
+    await stopTestServer();
+  });
+
+  describe('N3 Patch', () => {
+    it('should insert a triple into a JSON-LD resource', async () => {
+      // Create initial resource
+      const initial = {
+        '@context': { 'foaf': 'http://xmlns.com/foaf/0.1/' },
+        '@id': '#me',
+        'foaf:name': 'Alice'
+      };
+
+      await request('/patchtest/public/patch-insert.json', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/ld+json' },
+        body: JSON.stringify(initial),
+        auth: 'patchtest'
+      });
+
+      // Apply N3 Patch to insert a new triple
+      const patch = `
+        @prefix solid: <http://www.w3.org/ns/solid/terms#>.
+        @prefix foaf: <http://xmlns.com/foaf/0.1/>.
+        _:patch a solid:InsertDeletePatch;
+          solid:inserts { <#me> foaf:mbox <mailto:alice@example.org> }.
+      `;
+
+      const res = await request('/patchtest/public/patch-insert.json', {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'text/n3' },
+        body: patch,
+        auth: 'patchtest'
+      });
+
+      assertStatus(res, 204);
+
+      // Verify the change
+      const verify = await request('/patchtest/public/patch-insert.json');
+      const data = await verify.json();
+
+      assert.ok(data['foaf:mbox'], 'Should have new mbox property');
+    });
+
+    it('should delete a triple from a JSON-LD resource', async () => {
+      // Create initial resource with multiple properties
+      const initial = {
+        '@context': { 'foaf': 'http://xmlns.com/foaf/0.1/' },
+        '@id': '#me',
+        'foaf:name': 'Bob',
+        'foaf:age': 30
+      };
+
+      await request('/patchtest/public/patch-delete.json', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/ld+json' },
+        body: JSON.stringify(initial),
+        auth: 'patchtest'
+      });
+
+      // Apply N3 Patch to delete the age property
+      const patch = `
+        @prefix solid: <http://www.w3.org/ns/solid/terms#>.
+        @prefix foaf: <http://xmlns.com/foaf/0.1/>.
+        _:patch a solid:InsertDeletePatch;
+          solid:deletes { <#me> foaf:age 30 }.
+      `;
+
+      const res = await request('/patchtest/public/patch-delete.json', {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'text/n3' },
+        body: patch,
+        auth: 'patchtest'
+      });
+
+      assertStatus(res, 204);
+
+      // Verify the change
+      const verify = await request('/patchtest/public/patch-delete.json');
+      const data = await verify.json();
+
+      assert.ok(!data['foaf:age'], 'Should not have age property');
+      assert.strictEqual(data['foaf:name'], 'Bob', 'Should still have name');
+    });
+
+    it('should insert and delete in same patch', async () => {
+      // Create initial resource
+      const initial = {
+        '@context': { 'foaf': 'http://xmlns.com/foaf/0.1/' },
+        '@id': '#me',
+        'foaf:name': 'Charlie'
+      };
+
+      await request('/patchtest/public/patch-both.json', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/ld+json' },
+        body: JSON.stringify(initial),
+        auth: 'patchtest'
+      });
+
+      // Apply N3 Patch to change name
+      const patch = `
+        @prefix solid: <http://www.w3.org/ns/solid/terms#>.
+        @prefix foaf: <http://xmlns.com/foaf/0.1/>.
+        _:patch a solid:InsertDeletePatch;
+          solid:deletes { <#me> foaf:name "Charlie" };
+          solid:inserts { <#me> foaf:name "Charles" }.
+      `;
+
+      const res = await request('/patchtest/public/patch-both.json', {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'text/n3' },
+        body: patch,
+        auth: 'patchtest'
+      });
+
+      assertStatus(res, 204);
+
+      // Verify the change
+      const verify = await request('/patchtest/public/patch-both.json');
+      const data = await verify.json();
+
+      assert.strictEqual(data['foaf:name'], 'Charles', 'Name should be updated');
+    });
+
+    it('should add a new subject node', async () => {
+      // Create initial resource with @graph
+      const initial = {
+        '@context': { 'foaf': 'http://xmlns.com/foaf/0.1/' },
+        '@graph': [
+          { '@id': '#alice', 'foaf:name': 'Alice' }
+        ]
+      };
+
+      await request('/patchtest/public/patch-newnode.json', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/ld+json' },
+        body: JSON.stringify(initial),
+        auth: 'patchtest'
+      });
+
+      // Add a new person
+      const patch = `
+        @prefix solid: <http://www.w3.org/ns/solid/terms#>.
+        @prefix foaf: <http://xmlns.com/foaf/0.1/>.
+        _:patch a solid:InsertDeletePatch;
+          solid:inserts { <#bob> foaf:name "Bob" }.
+      `;
+
+      const res = await request('/patchtest/public/patch-newnode.json', {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'text/n3' },
+        body: patch,
+        auth: 'patchtest'
+      });
+
+      assertStatus(res, 204);
+
+      // Verify the change
+      const verify = await request('/patchtest/public/patch-newnode.json');
+      const data = await verify.json();
+
+      assert.ok(data['@graph'], 'Should have @graph');
+      assert.strictEqual(data['@graph'].length, 2, 'Should have 2 nodes');
+    });
+  });
+
+  describe('PATCH Error Handling', () => {
+    it('should return 415 for unsupported content type', async () => {
+      // Create a resource first
+      await request('/patchtest/public/patch-error.json', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ test: true }),
+        auth: 'patchtest'
+      });
+
+      const res = await request('/patchtest/public/patch-error.json', {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ op: 'add' }),
+        auth: 'patchtest'
+      });
+
+      assertStatus(res, 415);
+    });
+
+    it('should return 404 for non-existent resource', async () => {
+      const patch = `
+        @prefix solid: <http://www.w3.org/ns/solid/terms#>.
+        _:patch a solid:InsertDeletePatch;
+          solid:inserts { <#me> <http://example.org/p> "test" }.
+      `;
+
+      const res = await request('/patchtest/public/nonexistent.json', {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'text/n3' },
+        body: patch,
+        auth: 'patchtest'
+      });
+
+      assertStatus(res, 404);
+    });
+
+    it('should return 409 when patching non-JSON-LD resource', async () => {
+      // Create a plain text resource
+      await request('/patchtest/public/plain.txt', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'text/plain' },
+        body: 'Hello World',
+        auth: 'patchtest'
+      });
+
+      const patch = `
+        @prefix solid: <http://www.w3.org/ns/solid/terms#>.
+        _:patch a solid:InsertDeletePatch;
+          solid:inserts { <#me> <http://example.org/p> "test" }.
+      `;
+
+      const res = await request('/patchtest/public/plain.txt', {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'text/n3' },
+        body: patch,
+        auth: 'patchtest'
+      });
+
+      assertStatus(res, 409);
+    });
+
+    it('should return 409 for PATCH to container', async () => {
+      const patch = `
+        @prefix solid: <http://www.w3.org/ns/solid/terms#>.
+        _:patch a solid:InsertDeletePatch;
+          solid:inserts { <#me> <http://example.org/p> "test" }.
+      `;
+
+      const res = await request('/patchtest/public/', {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'text/n3' },
+        body: patch,
+        auth: 'patchtest'
+      });
+
+      assertStatus(res, 409);
+    });
+
+    it('should require authentication for PATCH', async () => {
+      // Create a resource first
+      await request('/patchtest/public/patch-auth.json', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ test: true }),
+        auth: 'patchtest'
+      });
+
+      const patch = `
+        @prefix solid: <http://www.w3.org/ns/solid/terms#>.
+        _:patch a solid:InsertDeletePatch;
+          solid:inserts { <#me> <http://example.org/p> "test" }.
+      `;
+
+      // Try without auth
+      const res = await request('/patchtest/public/patch-auth.json', {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'text/n3' },
+        body: patch
+        // No auth
+      });
+
+      assertStatus(res, 401);
+    });
+  });
+});