Refactor patch handler to perform everything but parsing.

Author: RubenVerborgh

lib/handlers/patch.js

@@ -13,20 +13,20 @@ const crypto = require('crypto')
 
 const DEFAULT_TARGET_TYPE = 'text/turtle'
 
-// Patch handlers by request body content type
-const PATCHERS = {
-  'application/sparql-update': require('./patch/sparql-update-patcher.js'),
-  'text/n3': require('./patch/n3-patcher.js')
+// Patch parsers by request body content type
+const PATCH_PARSERS = {
+  'application/sparql-update': require('./patch/sparql-update-parser.js'),
+  'text/n3': require('./patch/n3-patch-parser.js')
 }
 
 // Handles a PATCH request
 function patchHandler (req, res, next) {
-  debug('PATCH -- ' + req.originalUrl)
+  debug(`PATCH -- ${req.originalUrl}`)
   res.header('MS-Author-Via', 'SPARQL')
 
   // Obtain details of the target resource
   const ldp = req.app.locals.ldp
-  const root = !ldp.idp ? ldp.root : ldp.root + req.hostname + '/'
+  const root = !ldp.idp ? ldp.root : `${ldp.root}${req.hostname}/`
   const target = {}
   target.file = utils.uriToFilename(req.path, root)
   target.uri = utils.uriAbs(req) + req.originalUrl
@@ -39,17 +39,18 @@ function patchHandler (req, res, next) {
   patch.uri = `${target.uri}#patch-${hash(patch.text)}`
   patch.contentType = (req.get('content-type') || '').match(/^[^;\s]*/)[0]
   debug('PATCH -- Received patch (%d bytes, %s)', patch.text.length, patch.contentType)
-
-  // Find the appropriate patcher for the given content type
-  const patchGraph = PATCHERS[patch.contentType]
-  if (!patchGraph) {
-    return next(error(415, 'Unsupported patch content type: ' + patch.contentType))
+  const parsePatch = PATCH_PARSERS[patch.contentType]
+  if (!parsePatch) {
+    return next(error(415, `Unsupported patch content type: ${patch.contentType}`))
   }
 
-  // Read the RDF graph to be patched from the file
-  readGraph(target)
+  // Parse the target graph and the patch document
+  Promise.all([
+    readGraph(target),
+    parsePatch(target.uri, patch.uri, patch.text)
+  ])
   // Patch the graph and write it back to the file
-  .then(graph => patchGraph(graph, target.uri, patch.uri, patch.text))
+  .then(([graph, patchObject]) => applyPatch(patchObject, graph, target))
   .then(graph => writeGraph(graph, target))
   // Send the result to the client
   .then(result => { res.send(result) })
@@ -74,7 +75,7 @@ function readGraph (resource) {
           fileContents = ''
         // Fail on all other errors
         } else {
-          return reject(error(500, 'Patch: Original file read error:' + err))
+          return reject(error(500, `Original file read error: ${err}`))
         }
       }
       debug('PATCH -- Read target file (%d bytes)', fileContents.length)
@@ -88,22 +89,38 @@ function readGraph (resource) {
     try {
       $rdf.parse(fileContents, graph, resource.uri, resource.contentType)
     } catch (err) {
-      throw error(500, 'Patch: Target ' + resource.contentType + ' file syntax error:' + err)
+      throw error(500, `Patch: Target ${resource.contentType} file syntax error: ${err}`)
     }
     debug('PATCH -- Parsed target file')
     return graph
   })
 }
 
+// Applies the patch to the RDF graph
+function applyPatch (patchObject, graph, target) {
+  debug('PATCH -- Applying patch')
+  return new Promise((resolve, reject) =>
+    graph.applyPatch(patchObject, graph.sym(target.uri), (err) => {
+      if (err) {
+        const message = err.message || err // returns string at the moment
+        debug(`PATCH -- FAILED. Returning 409. Message: '${message}'`)
+        return reject(error(409, `The patch could not be applied. ${message}`))
+      }
+      resolve(graph)
+    })
+  )
+}
+
 // Writes the RDF graph to the given resource
 function writeGraph (graph, resource) {
+  debug('PATCH -- Writing patched file')
   return new Promise((resolve, reject) => {
     const resourceSym = graph.sym(resource.uri)
     const serialized = $rdf.serialize(resourceSym, graph, resource.uri, resource.contentType)
 
     fs.writeFile(resource.file, serialized, {encoding: 'utf8'}, function (err) {
       if (err) {
-        return reject(error(500, 'Failed to write file back after patch: ' + err))
+        return reject(error(500, `Failed to write file after patch: ${err}`))
       }
       debug('PATCH -- applied successfully')
       resolve('Patch applied successfully.\n')

lib/handlers/patch/n3-patcher.js renamed to lib/handlers/patch/n3-patch-parser.js

@@ -1,34 +1,22 @@
-// Performs a text/n3 patch on a graph
+// Parses a text/n3 patch
 
-module.exports = patch
+module.exports = parsePatchDocument
 
 const $rdf = require('rdflib')
-const debug = require('../../debug').handlers
 const error = require('../../http-error')
 
 const PATCH_NS = 'http://example.org/patch#'
 const PREFIXES = `PREFIX p: <${PATCH_NS}>\n`
 
-// Patches the given graph
-function patch (targetKB, targetURI, patchURI, patchText) {
-  const patchKB = $rdf.graph()
-  const target = patchKB.sym(targetURI)
-
-  return parsePatchDocument(targetURI, patchURI, patchText, patchKB)
-         .then(patchObject => applyPatch(patchObject, target, targetKB))
-}
-
 // Parses the given N3 patch document
-function parsePatchDocument (targetURI, patchURI, patchText, patchKB) {
-  debug('PATCH -- Parsing patch...')
-
+function parsePatchDocument (targetURI, patchURI, patchText) {
   // Parse the N3 document into triples
   return new Promise((resolve, reject) => {
     const patchGraph = $rdf.graph()
     $rdf.parse(patchText, patchGraph, patchURI, 'text/n3')
     resolve(patchGraph)
   })
-  .catch(err => { throw error(400, `Invalid patch document: ${err}`) })
+  .catch(err => { throw error(400, `Patch document syntax error: ${err}`) })
 
   // Query the N3 document for insertions and deletions
   .then(patchGraph => queryForFirstResult(patchGraph, `${PREFIXES}
@@ -51,20 +39,6 @@ function parsePatchDocument (targetURI, patchURI, patchText, patchKB) {
   })
 }
 
-// Applies the patch to the target graph
-function applyPatch (patchObject, target, targetKB) {
-  return new Promise((resolve, reject) =>
-    targetKB.applyPatch(patchObject, target, (err) => {
-      if (err) {
-        const message = err.message || err // returns string at the moment
-        debug('PATCH FAILED. Returning 409. Message: \'' + message + '\'')
-        return reject(error(409, `The patch could not be applied. ${message}`))
-      }
-      resolve(targetKB)
-    })
-  )
-}
-
 // Queries the store with the given SPARQL query and returns the first result
 function queryForFirstResult (store, sparql) {
   return new Promise((resolve, reject) => {

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

@@ -0,0 +1,18 @@
+// Parses an application/sparql-update patch
+
+module.exports = parsePatchDocument
+
+const $rdf = require('rdflib')
+const error = require('../../http-error')
+
+// Parses the given SPARQL UPDATE document
+function parsePatchDocument (targetURI, patchURI, patchText) {
+  return new Promise((resolve, reject) => {
+    const baseURI = patchURI.replace(/#.*/, '')
+    try {
+      resolve($rdf.sparqlUpdateParser(patchText, $rdf.graph(), baseURI))
+    } catch (err) {
+      reject(error(400, `Patch document syntax error: ${err}`))
+    }
+  })
+}

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

@@ -51,7 +51,7 @@ describe('PATCH', () => {
         .send('invalid')
         .expect(400)
         .then(response => {
-          assert.include(response.text, 'Invalid patch document')
+          assert.include(response.text, 'Patch document syntax error')
         })
     )
   })