Use ResourceMapper in patch handler

Author: rubensworks

lib/handlers/patch.js

@@ -3,61 +3,60 @@
 module.exports = handler
 
 const bodyParser = require('body-parser')
-const mime = require('mime-types')
 const fs = require('fs')
 const debug = require('../debug').handlers
-const utils = require('../utils.js')
 const error = require('../http-error')
 const $rdf = require('rdflib')
 const crypto = require('crypto')
 const overQuota = require('../utils').overQuota
 
-const DEFAULT_TARGET_TYPE = 'text/turtle'
-
 // 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) {
+async function patchHandler (req, res, next) {
   debug(`PATCH -- ${req.originalUrl}`)
   res.header('MS-Author-Via', 'SPARQL')
+  try {
+    // Obtain details of the target resource
+    const ldp = req.app.locals.ldp
+    const { path, contentType } = await ldp.resourceMapper.mapUrlToFile({ url: req })
+    const { url } = await ldp.resourceMapper.mapFileToUrl({ path, hostname: req.hostname })
+    const resource = { path, contentType, url }
+    debug('PATCH -- Target <%s> (%s)', url, contentType)
+
+    // Obtain details of the patch document
+    const patch = {}
+    patch.text = req.body ? req.body.toString() : ''
+    patch.uri = `${url}#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)
+    const parsePatch = PATCH_PARSERS[patch.contentType]
+    if (!parsePatch) {
+      throw error(415, `Unsupported patch content type: ${patch.contentType}`)
+    }
 
-  // Obtain details of the target resource
-  const ldp = req.app.locals.ldp
-  const root = !ldp.multiuser ? ldp.root : `${ldp.root}${req.hostname}/`
-  const target = {}
-  target.file = utils.uriToFilename(req.path, root)
-  target.uri = utils.getBaseUri(req) + req.originalUrl
-  target.contentType = mime.lookup(target.file) || DEFAULT_TARGET_TYPE
-  debug('PATCH -- Target <%s> (%s)', target.uri, target.contentType)
-
-  // Obtain details of the patch document
-  const patch = {}
-  patch.text = req.body ? req.body.toString() : ''
-  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)
-  const parsePatch = PATCH_PARSERS[patch.contentType]
-  if (!parsePatch) {
-    return next(error(415, `Unsupported patch content type: ${patch.contentType}`))
+    // Parse the target graph and the patch document,
+    // and verify permission for performing this specific patch
+    const [graph, patchObject] = await Promise.all([
+      readGraph(resource),
+      parsePatch(url, patch.uri, patch.text)
+        .then(patchObject => checkPermission(req, patchObject))
+    ])
+
+    // Patch the graph and write it back to the file
+    await applyPatch(patchObject, graph, url)
+    const result = await writeGraph(graph, resource, ldp.resourceMapper.rootPath, ldp.serverUri)
+
+    // Send the result to the client
+    res.send(result)
+  } catch (err) {
+    return next(err)
   }
-
-  // Parse the target graph and the patch document,
-  // and verify permission for performing this specific patch
-  Promise.all([
-    readGraph(target),
-    parsePatch(target.uri, patch.uri, patch.text)
-      .then(patchObject => checkPermission(target, req, patchObject))
-  ])
-  // Patch the graph and write it back to the file
-  .then(([graph, patchObject]) => applyPatch(patchObject, graph, target))
-    .then(graph => writeGraph(graph, target, root, ldp.serverUri))
-  // Send the result to the client
-  .then(result => { res.send(result) })
-  .then(next, next)
+  return next()
 }
 
 // Reads the request body and calls the actual patch handler
@@ -70,7 +69,7 @@ const readEntity = bodyParser.text({ type: () => true })
 function readGraph (resource) {
   // Read the resource's file
   return new Promise((resolve, reject) =>
-    fs.readFile(resource.file, {encoding: 'utf8'}, function (err, fileContents) {
+    fs.readFile(resource.path, {encoding: 'utf8'}, function (err, fileContents) {
       if (err) {
         // If the file does not exist, assume empty contents
         // (it will be created after a successful patch)
@@ -88,9 +87,9 @@ function readGraph (resource) {
   // Parse the resource's file contents
   .then((fileContents) => {
     const graph = $rdf.graph()
-    debug('PATCH -- Reading %s with content type %s', resource.uri, resource.contentType)
+    debug('PATCH -- Reading %s with content type %s', resource.url, resource.contentType)
     try {
-      $rdf.parse(fileContents, graph, resource.uri, resource.contentType)
+      $rdf.parse(fileContents, graph, resource.url, resource.contentType)
     } catch (err) {
       throw error(500, `Patch: Target ${resource.contentType} file syntax error: ${err}`)
     }
@@ -100,7 +99,7 @@ function readGraph (resource) {
 }
 
 // Verifies whether the user is allowed to perform the patch on the target
-function checkPermission (target, request, patchObject) {
+function checkPermission (request, patchObject) {
   // If no ACL object was passed down, assume permissions are okay.
   if (!request.acl) return Promise.resolve(patchObject)
   // At this point, we already assume append access,
@@ -123,10 +122,10 @@ function checkPermission (target, request, patchObject) {
 }
 
 // Applies the patch to the RDF graph
-function applyPatch (patchObject, graph, target) {
+function applyPatch (patchObject, graph, url) {
   debug('PATCH -- Applying patch')
   return new Promise((resolve, reject) =>
-    graph.applyPatch(patchObject, graph.sym(target.uri), (err) => {
+    graph.applyPatch(patchObject, graph.sym(url), (err) => {
       if (err) {
         const message = err.message || err // returns string at the moment
         debug(`PATCH -- FAILED. Returning 409. Message: '${message}'`)
@@ -141,8 +140,8 @@ function applyPatch (patchObject, graph, target) {
 function writeGraph (graph, resource, root, serverUri) {
   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)
+    const resourceSym = graph.sym(resource.url)
+    const serialized = $rdf.serialize(resourceSym, graph, resource.url, resource.contentType)
 
     // First check if we are above quota
     overQuota(root, serverUri).then((isOverQuota) => {
@@ -151,7 +150,7 @@ function writeGraph (graph, resource, root, serverUri) {
           'User has exceeded their storage quota'))
       }
 
-      fs.writeFile(resource.file, serialized, {encoding: 'utf8'}, function (err) {
+      fs.writeFile(resource.path, serialized, {encoding: 'utf8'}, function (err) {
         if (err) {
           return reject(error(500, `Failed to write file after patch: ${err}`))
         }

test/integration/ldp-test.js

@@ -212,10 +212,14 @@ describe('LDP', function () {
 
     after(async function () {
       // Clean up after delete tests
-      await ldp.delete('/resources/dummy/testPutBlocking.txt')
-      await ldp.delete('/resources/dummy/dummy2/testPutBlocking.txt')
-      await ldp.delete('/resources/dummy/dummy2/')
-      await ldp.delete('/resources/dummy/')
+      try {
+        await ldp.delete('/resources/dummy/testPutBlocking.txt')
+        await ldp.delete('/resources/dummy/dummy2/testPutBlocking.txt')
+        await ldp.delete('/resources/dummy/dummy2/')
+        await ldp.delete('/resources/dummy/')
+      } catch (err) {
+
+      }
     })
   })
   describe('listContainer', function () {