Wire up ResourceMapper

config/defaults.js

@@ -13,8 +13,7 @@ module.exports = {
   'webid': true,
   'strictOrigin': true,
   'originsAllowed': ['https://apps.solid.invalid'],
-  'dataBrowserPath': 'default',
-  'defaultContentType': 'text/turtle'
+  'dataBrowserPath': 'default'
 
   // For use in Enterprises to configure a HTTP proxy for all outbound HTTP requests from the SOLID server (we use
   // https://www.npmjs.com/package/global-tunnel-ng).

lib/create-app.js

@@ -23,7 +23,7 @@ const options = require('./handlers/options')
 const debug = require('./debug').authentication
 const path = require('path')
 const { routeResolvedFile } = require('./utils')
-const LegacyResourceMapper = require('./legacy-resource-mapper')
+const ResourceMapper = require('./resource-mapper')
 
 const corsSettings = cors({
   methods: [
@@ -42,7 +42,7 @@ function createApp (argv = {}) {
 
   argv.host = SolidHost.from({ port: argv.port, serverUri: argv.serverUri })
 
-  argv.resourceMapper = new LegacyResourceMapper({
+  argv.resourceMapper = new ResourceMapper({
     rootUrl: argv.serverUri,
     rootPath: argv.root || process.cwd(),
     includeHost: argv.multiuser,

lib/handlers/copy.js

@@ -22,17 +22,16 @@ async function handler (req, res, next) {
   const ldp = req.app.locals.ldp
   const serverRoot = ldp.resourceMapper.resolveUrl(req.hostname)
   const copyFromUrl = fromExternal ? copyFrom : serverRoot + copyFrom
-  const copyTo = res.locals.path || req.path
-  const { path: copyToPath } = await ldp.resourceMapper.mapUrlToFile({ url: 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/get.js

@@ -75,16 +75,15 @@ async function handler (req, res, next) {
   // Till here it must exist
   if (!includeBody) {
     debug('HEAD only')
-    const mappedFile = await ldp.resourceMapper.mapFileToUrl({ path })
-    contentType = mappedFile.contentType
-    res.setHeader('Content-Type', contentType)
+    res.setHeader('Content-Type', ret.contentType)
     res.status(200).send('OK')
     return next()
   }
 
   // Handle dataBrowser
   if (requestedType && requestedType.includes('text/html')) {
-    let mimeTypeByExt = mime.lookup(_path.basename(path))
+    const { path: filename } = await ldp.resourceMapper.mapUrlToFile({ url: options })
+    let mimeTypeByExt = mime.lookup(_path.basename(filename))
     let isHtmlResource = mimeTypeByExt && mimeTypeByExt.includes('html')
     let useDataBrowser = ldp.dataBrowserPath && (
       container ||
@@ -136,7 +135,9 @@ async function handler (req, res, next) {
 
 async function globHandler (req, res, next) {
   const ldp = req.app.locals.ldp
-  const { path: filename } = await ldp.resourceMapper.mapUrlToFile({ url: req })
+  // TODO: This is a hack, that does not check if the target file exists, as this is quite complex with globbing.
+  // TODO: Proper support for this is not implemented, as globbing support might be removed in the future.
+  const filename = ldp.resourceMapper._getFullPath(req)
   const requestUri = (await ldp.resourceMapper.mapFileToUrl({ path: filename, hostname: req.hostname })).url
 
   const globOptions = {

lib/handlers/index.js

@@ -9,9 +9,10 @@ async function handler (req, res, next) {
   const ldp = req.app.locals.ldp
   const negotiator = new Negotiator(req)
   const requestedType = negotiator.mediaType()
-  const { path: filename } = await req.app.locals.ldp.resourceMapper.mapUrlToFile({ url: req })
 
   try {
+    const { path: filename } = await req.app.locals.ldp.resourceMapper.mapUrlToFile({ url: req })
+
     const stats = await ldp.stat(filename)
     if (!stats.isDirectory()) {
       return next()

lib/handlers/patch.js

@@ -9,21 +9,32 @@ const error = require('../http-error')
 const $rdf = require('rdflib')
 const crypto = require('crypto')
 const overQuota = require('../utils').overQuota
+const getContentType = require('../utils').getContentType
 
 // 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')
 }
 
+const DEFAULT_FOR_NEW_CONTENT_TYPE = 'text/turtle'
+
 // Handles a PATCH request
 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 })
+    let path, contentType
+    try {
+      // First check if the file already exists
+      ({ path, contentType } = await ldp.resourceMapper.mapUrlToFile({ url: req }))
+    } catch (err) {
+      // If the file doesn't exist, request one to be created with the default content type
+      ({ path, contentType } = await ldp.resourceMapper.mapUrlToFile(
+        { url: req, createIfNotExists: true, contentType: DEFAULT_FOR_NEW_CONTENT_TYPE }))
+    }
     const { url } = await ldp.resourceMapper.mapFileToUrl({ path, hostname: req.hostname })
     const resource = { path, contentType, url }
     debug('PATCH -- Target <%s> (%s)', url, contentType)
@@ -32,7 +43,7 @@ async function patchHandler (req, res, next) {
     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]
+    patch.contentType = getContentType(req.headers)
     debug('PATCH -- Received patch (%d bytes, %s)', patch.text.length, patch.contentType)
     const parsePatch = PATCH_PARSERS[patch.contentType]
     if (!parsePatch) {

lib/handlers/post.js

@@ -7,10 +7,11 @@ const header = require('../header')
 const patch = require('./patch')
 const error = require('../http-error')
 const { extensions } = require('mime-types')
+const getContentType = require('../utils').getContentType
 
 async function handler (req, res, next) {
   const ldp = req.app.locals.ldp
-  const contentType = req.get('content-type')
+  const contentType = getContentType(req.headers)
   debug('content-type is ', contentType)
   // Handle SPARQL(-update?) query
   if (contentType === 'application/sparql' ||
@@ -58,7 +59,7 @@ async function handler (req, res, next) {
       const { url: putUrl } = await ldp.resourceMapper.mapFileToUrl(
         { path: ldp.resourceMapper._rootPath + path.join(containerPath, filename), hostname: req.hostname })
       try {
-        await ldp.put(putUrl, file)
+        await ldp.put(putUrl, file, mimetype)
       } catch (err) {
         busboy.emit('error', err)
       }

lib/handlers/put.js

@@ -1,14 +1,15 @@
 module.exports = handler
 
 const debug = require('debug')('solid:put')
+const getContentType = require('../utils').getContentType
 
 async function handler (req, res, next) {
   const ldp = req.app.locals.ldp
   debug(req.originalUrl)
   res.header('MS-Author-Via', 'SPARQL')
 
   try {
-    await ldp.put(req, req)
+    await ldp.put(req, req, getContentType(req.headers))
     debug('succeded putting the file')
 
     res.sendStatus(201)

lib/header.js

@@ -43,7 +43,19 @@ function addLinks (res, fileMetadata) {
 
 async function linksHandler (req, res, next) {
   const ldp = req.app.locals.ldp
-  const { path: filename } = await ldp.resourceMapper.mapUrlToFile(req)
+  let filename
+  try {
+    // Hack: createIfNotExists is set to true for PUT or PATCH requests
+    // because the file might not exist yet at this point.
+    // But it will be created afterwards.
+    // This should be improved with the new server architecture.
+    ({ path: filename } = await ldp.resourceMapper
+      .mapUrlToFile({ url: req, createIfNotExists: req.method === 'PUT' || req.method === 'PATCH' }))
+  } catch (e) {
+    // Silently ignore errors here
+    // Later handlers will error as well, but they will be able to given a more concrete error message (like 400 or 404)
+    return next()
+  }
 
   if (path.extname(filename) === ldp.suffixMeta) {
     debug.metadata('Trying to access metadata file as regular file.')

lib/ldp-copy.js

@@ -3,9 +3,11 @@ module.exports = copy
 const debug = require('./debug')
 const fs = require('fs')
 const mkdirp = require('fs-extra').mkdirp
+const error = require('./http-error')
 const path = require('path')
 const http = require('http')
 const https = require('https')
+const getContentType = require('./utils').getContentType
 
 /**
  * Cleans up a file write stream (ends stream, deletes the file).
@@ -21,47 +23,51 @@ function cleanupFileStream (stream) {
 
 /**
  * Performs an LDP Copy operation, imports a remote resource to a local path.
- * @param copyToPath {String} Local path to copy the resource into
+ * @param resourceMapper {ResourceMapper} A resource mapper instance.
+ * @param copyToUri {Object} The location (in the current domain) to copy to.
  * @param copyFromUri {String} Location of remote resource to copy from
- * @param callback {Function} Node error callback
+ * @return A promise resolving when the copy operation is finished
  */
-function copy (copyToPath, copyFromUri, callback) {
-  mkdirp(path.dirname(copyToPath), function (err) {
-    if (err) {
-      debug.handlers('COPY -- Error creating destination directory: ' + err)
-      return callback(
-        new Error('Failed to create the path to the destination resource: ' +
-          err))
-    }
-    const destinationStream = fs.createWriteStream(copyToPath)
-      .on('error', function (err) {
-        cleanupFileStream(this)
-        return callback(new Error('Error writing data: ' + err))
-      })
-      .on('finish', function () {
-        // Success
-        debug.handlers('COPY -- Wrote data to: ' + copyToPath)
-        callback()
-      })
+function copy (resourceMapper, copyToUri, copyFromUri) {
+  return new Promise((resolve, reject) => {
     const request = /^https:/.test(copyFromUri) ? https : http
     request.get(copyFromUri)
       .on('error', function (err) {
         debug.handlers('COPY -- Error requesting source file: ' + err)
         this.end()
-        cleanupFileStream(destinationStream)
-        return callback(new Error('Error writing data: ' + err))
+        return reject(new Error('Error writing data: ' + err))
       })
       .on('response', function (response) {
         if (response.statusCode !== 200) {
-          debug.handlers('COPY -- HTTP error reading source file: ' +
-            response.statusMessage)
+          debug.handlers('COPY -- HTTP error reading source file: ' + response.statusMessage)
           this.end()
-          cleanupFileStream(destinationStream)
           let error = new Error('Error reading source file: ' + response.statusMessage)
           error.statusCode = response.statusCode
-          return callback(error)
+          return reject(error)
         }
-        response.pipe(destinationStream)
+        // Grab the content type from the source
+        const contentType = getContentType(response.headers)
+        resourceMapper.mapUrlToFile({ url: copyToUri, createIfNotExists: true, contentType })
+          .then(({ path: copyToPath }) => {
+            mkdirp(path.dirname(copyToPath), function (err) {
+              if (err) {
+                debug.handlers('COPY -- Error creating destination directory: ' + err)
+                return reject(new Error('Failed to create the path to the destination resource: ' + err))
+              }
+              const destinationStream = fs.createWriteStream(copyToPath)
+                .on('error', function (err) {
+                  cleanupFileStream(this)
+                  return reject(new Error('Error writing data: ' + err))
+                })
+                .on('finish', function () {
+                  // Success
+                  debug.handlers('COPY -- Wrote data to: ' + copyToPath)
+                  resolve()
+                })
+              response.pipe(destinationStream)
+            })
+          })
+          .catch(() => reject(error(500, 'Could not find target file to copy')))
       })
   })
 }