Wire up ResourceMapper

lib/capability-discovery.js

@@ -3,7 +3,6 @@
  * @module capability-discovery
  */
 const express = require('express')
-const util = require('./utils')
 
 const serviceConfigDefaults = {
   'api': {
@@ -47,7 +46,7 @@ function capabilityDiscovery () {
 function serviceCapabilityDocument (serviceConfig) {
   return (req, res) => {
     // Add the server root url
-    serviceConfig.root = util.getFullUri(req) // TODO make sure we align with the rest
+    serviceConfig.root = req.app.locals.ldp.resourceMapper.getBaseUrl(req.hostname, req.path)
     // Add the 'apps' urls section
     serviceConfig.apps = req.app.locals.appUrls
     res.json(serviceConfig)

lib/create-app.js

@@ -23,6 +23,7 @@ const options = require('./handlers/options')
 const debug = require('./debug').authentication
 const path = require('path')
 const { routeResolvedFile } = require('./utils')
+const ResourceMapper = require('./resource-mapper')
 
 const corsSettings = cors({
   methods: [
@@ -41,6 +42,12 @@ function createApp (argv = {}) {
 
   argv.host = SolidHost.from({ port: argv.port, serverUri: argv.serverUri })
 
+  argv.resourceMapper = new ResourceMapper({
+    rootUrl: argv.serverUri,
+    rootPath: argv.root,
+    includeHost: argv.multiuser
+  })
+
   const configPath = config.initConfigDir(argv)
   argv.templates = config.initTemplateDirs(configPath)
 

lib/handlers/allow.js

@@ -1,25 +1,17 @@
 module.exports = allow
 
 const ACL = require('../acl-checker')
-const $rdf = require('rdflib')
-const utils = require('../utils')
 const debug = require('../debug.js').ACL
-const LegacyResourceMapper = require('../legacy-resource-mapper')
 
 function allow (mode) {
-  return function allowHandler (req, res, next) {
+  return async function allowHandler (req, res, next) {
     const ldp = req.app.locals.ldp || {}
     if (!ldp.webid) {
       return next()
     }
 
     // Set up URL to filesystem mapping
-    const rootUrl = utils.getBaseUri(req)
-    const mapper = new LegacyResourceMapper({
-      rootUrl,
-      rootPath: ldp.root,
-      includeHost: ldp.multiuser
-    })
+    const rootUrl = ldp.resourceMapper.getBaseUrl(req.hostname)
 
     // Determine the actual path of the request
     // (This is used as an ugly hack to check the ACL status of other resources.)
@@ -28,36 +20,41 @@ function allow (mode) {
       : req.path
 
     // Check whether the resource exists
-    ldp.exists(req.hostname, reqPath, (err, ret) => {
-      // Ensure directories always end in a slash
-      const stat = err ? null : ret.stream
-      if (!reqPath.endsWith('/') && stat && stat.isDirectory()) {
-        reqPath += '/'
-      }
+    let stat
+    try {
+      const ret = await ldp.exists(req.hostname, reqPath)
+      stat = ret.stream
+    } catch (err) {
+      stat = null
+    }
 
-      // Obtain and store the ACL of the requested resource
-      req.acl = new ACL(rootUrl + reqPath, {
-        origin: req.get('origin'),
-        host: req.protocol + '://' + req.get('host'),
-        fetch: fetchFromLdp(mapper, ldp),
-        fetchGraph: (uri, options) => {
-          // first try loading from local fs
-          return ldp.getGraph(uri, options.contentType)
-            // failing that, fetch remote graph
-            .catch(() => ldp.fetchGraph(uri, options))
-        },
-        suffix: ldp.suffixAcl,
-        strictOrigin: ldp.strictOrigin
-      })
+    // Ensure directories always end in a slash
+    if (!reqPath.endsWith('/') && stat && stat.isDirectory()) {
+      reqPath += '/'
+    }
 
-      // Ensure the user has the required permission
-      const userId = req.session.userId
-      req.acl.can(userId, mode)
-        .then(() => next(), err => {
-          debug(`${mode} access denied to ${userId || '(none)'}`)
-          next(err)
-        })
+    // Obtain and store the ACL of the requested resource
+    req.acl = new ACL(rootUrl + reqPath, {
+      origin: req.get('origin'),
+      host: req.protocol + '://' + req.get('host'),
+      fetch: fetchFromLdp(ldp.resourceMapper, ldp),
+      fetchGraph: (uri, options) => {
+        // first try loading from local fs
+        return ldp.getGraph(uri, options.contentType)
+        // failing that, fetch remote graph
+          .catch(() => ldp.fetchGraph(uri, options))
+      },
+      suffix: ldp.suffixAcl,
+      strictOrigin: ldp.strictOrigin
     })
+
+    // Ensure the user has the required permission
+    const userId = req.session.userId
+    req.acl.can(userId, mode)
+      .then(() => next(), err => {
+        debug(`${mode} access denied to ${userId || '(none)'}`)
+        next(err)
+      })
   }
 }
 
@@ -71,19 +68,6 @@ function allow (mode) {
  */
 function fetchFromLdp (mapper, ldp) {
   return function fetch (url, callback) {
-    // Convert the URL into a filename
-    mapper.mapUrlToFile({ url })
-    // Read the file from disk
-    .then(({ path }) => new Promise((resolve, reject) => {
-      ldp.readFile(path, (e, c) => e ? reject(e) : resolve(c))
-    }))
-    // Parse the file as Turtle
-    .then(body => {
-      const graph = $rdf.graph()
-      $rdf.parse(body, graph, url, 'text/turtle')
-      return graph
-    })
-    // Return the ACL graph
-    .then(graph => callback(null, graph), callback)
+    ldp.getGraph(url).then(g => callback(null, g), callback)
   }
 }

lib/handlers/copy.js

@@ -3,7 +3,6 @@ module.exports = handler
 const debug = require('../debug')
 const error = require('../http-error')
 const ldpCopy = require('../ldp-copy')
-const utils = require('../utils')
 const url = require('url')
 
 /**
@@ -14,25 +13,25 @@ const url = require('url')
  * "Save an external resource to Solid" type apps.
  * @method handler
  */
-function handler (req, res, next) {
+async function handler (req, res, next) {
   const copyFrom = req.header('Source')
   if (!copyFrom) {
     return next(error(400, 'Source header required'))
   }
   const fromExternal = !!url.parse(copyFrom).hostname
-  const serverRoot = utils.getBaseUri(req)
+  const ldp = req.app.locals.ldp
+  const serverRoot = ldp.resourceMapper.getBaseUrl(req.hostname)
   const copyFromUrl = fromExternal ? copyFrom : serverRoot + copyFrom
-  const copyTo = res.locals.path || req.path
-  const copyToPath = utils.reqToPath(req)
-  ldpCopy(copyToPath, copyFromUrl, function (err) {
-    if (err) {
-      let statusCode = err.statusCode || 500
-      let errorMessage = err.statusMessage || err.message
-      debug.handlers('Error with COPY request:' + errorMessage)
-      return next(error(statusCode, errorMessage))
-    }
-    res.set('Location', copyTo)
-    res.sendStatus(201)
-    next()
-  })
+  const copyToUrl = res.locals.path || req.path
+  try {
+    await ldpCopy(ldp.resourceMapper, copyToUrl, copyFromUrl)
+  } catch (err) {
+    let statusCode = err.statusCode || 500
+    let errorMessage = err.statusMessage || err.message
+    debug.handlers('Error with COPY request:' + errorMessage)
+    return next(error(statusCode, errorMessage))
+  }
+  res.set('Location', copyToUrl)
+  res.sendStatus(201)
+  next()
 }

lib/handlers/delete.js

@@ -2,17 +2,17 @@ module.exports = handler
 
 const debug = require('../debug').handlers
 
-function handler (req, res, next) {
+async function handler (req, res, next) {
   debug('DELETE -- Request on' + req.originalUrl)
 
   const ldp = req.app.locals.ldp
-  ldp.delete(req.hostname, req.path, function (err) {
-    if (err) {
-      debug('DELETE -- Failed to delete: ' + err)
-      return next(err)
-    }
+  try {
+    await ldp.delete(req)
     debug('DELETE -- Ok.')
     res.sendStatus(200)
-    return next()
-  })
+    next()
+  } catch (err) {
+    debug('DELETE -- Failed to delete: ' + err)
+    next(err)
+  }
 }