Move patch writing to generic PATCH handler.

This reduces the task of individual patch handlers
to parsing the patch and applying it.

Author: RubenVerborgh

lib/handlers/patch.js

@@ -32,8 +32,8 @@ function patchHandler (req, res, next) {
   res.header('MS-Author-Via', 'SPARQL')
 
   var root = !ldp.idp ? ldp.root : ldp.root + req.hostname + '/'
-  var filename = utils.uriToFilename(req.path, root)
-  var targetContentType = mime.lookup(filename) || DEFAULT_CONTENT_TYPE
+  var targetFile = utils.uriToFilename(req.path, root)
+  var targetContentType = mime.lookup(targetFile) || DEFAULT_CONTENT_TYPE
   var patchContentType = req.get('content-type')
     ? req.get('content-type').split(';')[0].trim() // Ignore parameters
     : ''
@@ -42,29 +42,25 @@ function patchHandler (req, res, next) {
   debug('PATCH -- Content-type ' + patchContentType + ' patching target ' + targetContentType + ' <' + targetURI + '>')
 
   // Obtain a patcher for the given patch type
-  const patch = PATCHERS[patchContentType]
-  if (!patch) {
+  const patchGraph = PATCHERS[patchContentType]
+  if (!patchGraph) {
     return next(error(415, 'Unknown patch content type: ' + patchContentType))
   }
 
-  // Read the RDF graph to be patched
-  readGraph(filename, targetURI).then((targetKB) => {
-    // Patch the target graph
-    patch(targetKB, filename, targetURI, req.text, function (err, result) {
-      if (err) {
-        throw err
-      }
-      res.send(result)
-      next()
-    })
-  })
-  .catch(next)
+  // Read the RDF graph to be patched from the file
+  readGraph(targetFile, targetURI, targetContentType)
+  // Patch the graph and write it back to the file
+  .then(targetKB => patchGraph(targetKB, targetFile, targetURI, req.text))
+  .then(targetKB => writeGraph(targetKB, targetFile, targetURI, targetContentType))
+  // Send the result to the client
+  .then(result => { res.send(result) })
+  .then(next, next)
 }
 
 // Reads the RDF graph in the given file with the corresponding URI
-function readGraph (resourceFile, resourceURI) {
+function readGraph (resourceFile, resourceURI, contentType) {
   // Read the file
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve, reject) =>
     fs.readFile(resourceFile, {encoding: 'utf8'}, function (err, fileContents) {
       if (err) {
         // If the file does not exist, assume empty contents
@@ -79,11 +75,10 @@ function readGraph (resourceFile, resourceURI) {
       debug('PATCH -- Read target file (%d bytes)', fileContents.length)
       resolve(fileContents)
     })
-  })
+  )
   // Parse the file
   .then((fileContents) => {
     const graph = $rdf.graph()
-    const contentType = mime.lookup(resourceFile) || DEFAULT_CONTENT_TYPE
     debug('PATCH -- Reading %s with content type %s', resourceURI, contentType)
     try {
       $rdf.parse(fileContents, graph, resourceURI, contentType)
@@ -94,3 +89,19 @@ function readGraph (resourceFile, resourceURI) {
     return graph
   })
 }
+
+// Writes the RDF graph to the given file
+function writeGraph (graph, resourceFile, resourceURI, contentType) {
+  return new Promise((resolve, reject) => {
+    const resource = graph.sym(resourceURI)
+    const serialized = $rdf.serialize(resource, graph, resourceURI, contentType)
+
+    fs.writeFile(resourceFile, serialized, {encoding: 'utf8'}, function (err) {
+      if (err) {
+        return reject(error(500, 'Failed to write file back after patch: ' + err))
+      }
+      debug('PATCH -- applied OK (sync)')
+      resolve('Patch applied OK\n')
+    })
+  })
+}

lib/handlers/patch/sparql-update-patcher.js

@@ -1,45 +1,32 @@
 module.exports = patch
 
-var mime = require('mime-types')
-var fs = require('fs')
 var $rdf = require('rdflib')
 var debug = require('../../debug').handlers
 var error = require('../../http-error')
 
-const DEFAULT_CONTENT_TYPE = 'text/turtle'
+function patch (targetKB, filename, targetURI, text) {
+  return new Promise((resolve, reject) => {
+    var patchURI = targetURI // @@@ beware the triples from the patch ending up in the same place
+    var patchKB = $rdf.graph()
 
-function patch (targetKB, filename, targetURI, text, callback) {
-  var patchURI = targetURI // @@@ beware the triples from the patch ending up in the same place
-  var patchKB = $rdf.graph()
-  var targetContentType = mime.lookup(filename) || DEFAULT_CONTENT_TYPE
-
-  debug('PATCH -- parsing patch ...')
-  var patchObject
-  try {
-    // Must parse relative to document's base address but patch doc should get diff URI
-    patchObject = $rdf.sparqlUpdateParser(text, patchKB, patchURI)
-  } catch (e) {
-    return callback(error(400, 'Patch format syntax error:\n' + e + '\n'))
-  }
-  debug('PATCH -- reading target file ...')
-
-  var target = patchKB.sym(targetURI)
-  targetKB.applyPatch(patchObject, target, function (err) {
-    if (err) {
-      var message = err.message || err // returns string at the moment
-      debug('PATCH FAILED. Returning 409. Message: \'' + message + '\'')
-      return callback(error(409, 'Error when applying the patch'))
+    debug('PATCH -- parsing patch ...')
+    var patchObject
+    try {
+      // Must parse relative to document's base address but patch doc should get diff URI
+      patchObject = $rdf.sparqlUpdateParser(text, patchKB, patchURI)
+    } catch (e) {
+      return reject(error(400, 'Patch format syntax error:\n' + e + '\n'))
     }
-    debug('PATCH -- Patched. Writeback URI base ' + targetURI)
-    var data = $rdf.serialize(target, targetKB, targetURI, targetContentType)
-    // debug('Writeback data: ' + data)
+    debug('PATCH -- reading target file ...')
 
-    fs.writeFile(filename, data, {encoding: 'utf8'}, function (err, data) {
+    var target = patchKB.sym(targetURI)
+    targetKB.applyPatch(patchObject, target, function (err) {
       if (err) {
-        return callback(error(500, 'Failed to write file back after patch: ' + err))
+        var message = err.message || err // returns string at the moment
+        debug('PATCH FAILED. Returning 409. Message: \'' + message + '\'')
+        return reject(error(409, 'Error when applying the patch'))
       }
-      debug('PATCH -- applied OK (sync)')
-      return callback(null, 'Patch applied OK\n')
+      resolve(targetKB)
     })
   })
 }