solid-server 5.8.6 → 5.8.8-22f4cfec

package/lib/{header.js → header.mjs}

@@ -1,143 +1,138 @@
-module.exports.addLink = addLink
-module.exports.addLinks = addLinks
-module.exports.parseMetadataFromHeader = parseMetadataFromHeader
-module.exports.linksHandler = linksHandler
-module.exports.addPermissions = addPermissions
-
-const li = require('li')
-const path = require('path')
-const metadata = require('./metadata.js')
-const debug = require('./debug.js')
-const utils = require('./utils.js')
-const error = require('./http-error')
-
-const MODES = ['Read', 'Write', 'Append', 'Control']
-const PERMISSIONS = MODES.map(m => m.toLowerCase())
-
-function addLink (res, value, rel) {
-  const oldLink = res.get('Link')
-  if (oldLink === undefined) {
-    res.set('Link', '<' + value + '>; rel="' + rel + '"')
-  } else {
-    res.set('Link', oldLink + ', ' + '<' + value + '>; rel="' + rel + '"')
-  }
-}
-
-function addLinks (res, fileMetadata) {
-  if (fileMetadata.isResource) {
-    addLink(res, 'http://www.w3.org/ns/ldp#Resource', 'type')
-  }
-  if (fileMetadata.isSourceResource) {
-    addLink(res, 'http://www.w3.org/ns/ldp#RDFSource', 'type')
-  }
-  if (fileMetadata.isContainer) {
-    addLink(res, 'http://www.w3.org/ns/ldp#Container', 'type')
-  }
-  if (fileMetadata.isBasicContainer) {
-    addLink(res, 'http://www.w3.org/ns/ldp#BasicContainer', 'type')
-  }
-  if (fileMetadata.isDirectContainer) {
-    addLink(res, 'http://www.w3.org/ns/ldp#DirectContainer', 'type')
-  }
-  if (fileMetadata.isStorage) {
-    addLink(res, 'http://www.w3.org/ns/pim/space#Storage', 'type')
-  }
-}
-
-async function linksHandler (req, res, next) {
-  const ldp = req.app.locals.ldp
-  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.')
-
-    return next(error(404, 'Trying to access metadata file as regular file'))
-  }
-  const fileMetadata = new metadata.Metadata()
-  if (req.path.endsWith('/')) {
-    // do not add storage header in serverUri
-    if (req.path === '/') fileMetadata.isStorage = true
-    fileMetadata.isContainer = true
-    fileMetadata.isBasicContainer = true
-  } else {
-    fileMetadata.isResource = true
-  }
-  // Add LDP-required Accept-Post header for OPTIONS request to containers
-  if (fileMetadata.isContainer && req.method === 'OPTIONS') {
-    res.header('Accept-Post', '*/*')
-  }
-  // Add ACL and Meta Link in header
-  addLink(res, utils.pathBasename(req.path) + ldp.suffixAcl, 'acl')
-  addLink(res, utils.pathBasename(req.path) + ldp.suffixMeta, 'describedBy')
-  // Add other Link headers
-  addLinks(res, fileMetadata)
-  next()
-}
-
-function parseMetadataFromHeader (linkHeader) {
-  const fileMetadata = new metadata.Metadata()
-  if (linkHeader === undefined) {
-    return fileMetadata
-  }
-  const links = linkHeader.split(',')
-  for (const linkIndex in links) {
-    const link = links[linkIndex]
-    const parsedLinks = li.parse(link)
-    for (const rel in parsedLinks) {
-      if (rel === 'type') {
-        if (parsedLinks[rel] === 'http://www.w3.org/ns/ldp#Resource') {
-          fileMetadata.isResource = true
-        } else if (parsedLinks[rel] === 'http://www.w3.org/ns/ldp#RDFSource') {
-          fileMetadata.isSourceResource = true
-        } else if (parsedLinks[rel] === 'http://www.w3.org/ns/ldp#Container') {
-          fileMetadata.isContainer = true
-        } else if (parsedLinks[rel] === 'http://www.w3.org/ns/ldp#BasicContainer') {
-          fileMetadata.isBasicContainer = true
-        } else if (parsedLinks[rel] === 'http://www.w3.org/ns/ldp#DirectContainer') {
-          fileMetadata.isDirectContainer = true
-        } else if (parsedLinks[rel] === 'http://www.w3.org/ns/pim/space#Storage') {
-          fileMetadata.isStorage = true
-        }
-      }
-    }
-  }
-  return fileMetadata
-}
-
-// Adds a header that describes the user's permissions
-async function addPermissions (req, res, next) {
-  const { acl, session } = req
-  if (!acl) return next()
-
-  // Turn permissions for the public and the user into a header
-  const ldp = req.app.locals.ldp
-  const resource = ldp.resourceMapper.resolveUrl(req.hostname, req.path)
-  let [publicPerms, userPerms] = await Promise.all([
-    getPermissionsFor(acl, null, req),
-    getPermissionsFor(acl, session.userId, req)
-  ])
-  if (resource.endsWith('.acl') && userPerms === '' && await ldp.isOwner(session.userId, req.hostname)) userPerms = 'control'
-  debug.ACL(`Permissions on ${resource} for ${session.userId || '(none)'}: ${userPerms}`)
-  debug.ACL(`Permissions on ${resource} for public: ${publicPerms}`)
-  res.set('WAC-Allow', `user="${userPerms}",public="${publicPerms}"`)
-  next()
-}
-
-// Gets the permissions string for the given user and resource
-async function getPermissionsFor (acl, user, req) {
-  const accesses = MODES.map(mode => acl.can(user, mode))
-  const allowed = await Promise.all(accesses)
-  return PERMISSIONS.filter((mode, i) => allowed[i]).join(' ')
-}
+import li from 'li'
+import path from 'path'
+import metadata from './metadata.mjs'
+import debug from './debug.mjs'
+import { pathBasename } from './utils.mjs'
+import HTTPError from './http-error.mjs'
+
+const MODES = ['Read', 'Write', 'Append', 'Control']
+const PERMISSIONS = MODES.map(m => m.toLowerCase())
+
+export function addLink (res, value, rel) {
+  const oldLink = res.get('Link')
+  if (oldLink === undefined) {
+    res.set('Link', '<' + value + '>; rel="' + rel + '"')
+  } else {
+    res.set('Link', oldLink + ', ' + '<' + value + '>; rel="' + rel + '"')
+  }
+}
+
+export function addLinks (res, fileMetadata) {
+  if (fileMetadata.isResource) {
+    addLink(res, 'http://www.w3.org/ns/ldp#Resource', 'type')
+  }
+  if (fileMetadata.isSourceResource) {
+    addLink(res, 'http://www.w3.org/ns/ldp#RDFSource', 'type')
+  }
+  if (fileMetadata.isContainer) {
+    addLink(res, 'http://www.w3.org/ns/ldp#Container', 'type')
+  }
+  if (fileMetadata.isBasicContainer) {
+    addLink(res, 'http://www.w3.org/ns/ldp#BasicContainer', 'type')
+  }
+  if (fileMetadata.isDirectContainer) {
+    addLink(res, 'http://www.w3.org/ns/ldp#DirectContainer', 'type')
+  }
+  if (fileMetadata.isStorage) {
+    addLink(res, 'http://www.w3.org/ns/pim/space#Storage', 'type')
+  }
+}
+
+export async function linksHandler (req, res, next) {
+  const ldp = req.app.locals.ldp
+  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.')
+
+    return next(HTTPError(404, 'Trying to access metadata file as regular file'))
+  }
+  const fileMetadata = new metadata.Metadata()
+  if (req.path.endsWith('/')) {
+    // do not add storage header in serverUri
+    if (req.path === '/') fileMetadata.isStorage = true
+    fileMetadata.isContainer = true
+    fileMetadata.isBasicContainer = true
+  } else {
+    fileMetadata.isResource = true
+  }
+  // Add LDP-required Accept-Post header for OPTIONS request to containers
+  if (fileMetadata.isContainer && req.method === 'OPTIONS') {
+    res.header('Accept-Post', '*/*')
+  }
+  // Add ACL and Meta Link in header
+  addLink(res, pathBasename(req.path) + ldp.suffixAcl, 'acl')
+  addLink(res, pathBasename(req.path) + ldp.suffixMeta, 'describedBy')
+  // Add other Link headers
+  addLinks(res, fileMetadata)
+  next()
+}
+
+export function parseMetadataFromHeader (linkHeader) {
+  const fileMetadata = new metadata.Metadata()
+  if (linkHeader === undefined) {
+    return fileMetadata
+  }
+  const links = linkHeader.split(',')
+  for (const linkIndex in links) {
+    const link = links[linkIndex]
+    const parsedLinks = li.parse(link)
+    for (const rel in parsedLinks) {
+      if (rel === 'type') {
+        if (parsedLinks[rel] === 'http://www.w3.org/ns/ldp#Resource') {
+          fileMetadata.isResource = true
+        } else if (parsedLinks[rel] === 'http://www.w3.org/ns/ldp#RDFSource') {
+          fileMetadata.isSourceResource = true
+        } else if (parsedLinks[rel] === 'http://www.w3.org/ns/ldp#Container') {
+          fileMetadata.isContainer = true
+        } else if (parsedLinks[rel] === 'http://www.w3.org/ns/ldp#BasicContainer') {
+          fileMetadata.isBasicContainer = true
+        } else if (parsedLinks[rel] === 'http://www.w3.org/ns/ldp#DirectContainer') {
+          fileMetadata.isDirectContainer = true
+        } else if (parsedLinks[rel] === 'http://www.w3.org/ns/pim/space#Storage') {
+          fileMetadata.isStorage = true
+        }
+      }
+    }
+  }
+  return fileMetadata
+}
+
+// Adds a header that describes the user's permissions
+export async function addPermissions (req, res, next) {
+  const { acl, session } = req
+  if (!acl) return next()
+
+  // Turn permissions for the public and the user into a header
+  const ldp = req.app.locals.ldp
+  const resource = ldp.resourceMapper.resolveUrl(req.hostname, req.path)
+  let [publicPerms, userPerms] = await Promise.all([
+    getPermissionsFor(acl, null, req),
+    getPermissionsFor(acl, session.userId, req)
+  ])
+  if (resource.endsWith('.acl') && userPerms === '' && await ldp.isOwner(session.userId, req.hostname)) userPerms = 'control'
+  debug.ACL(`Permissions on ${resource} for ${session.userId || '(none)'}: ${userPerms}`)
+  debug.ACL(`Permissions on ${resource} for public: ${publicPerms}`)
+  // Set the header
+  res.set('WAC-Allow', `user="${userPerms}",public="${publicPerms}"`)
+  next()
+}
+
+// Gets the permissions string for the given user and resource
+async function getPermissionsFor (acl, user, req) {
+  const accesses = MODES.map(mode => acl.can(user, mode))
+  const allowed = await Promise.all(accesses)
+  return PERMISSIONS.filter((mode, i) => allowed[i]).join(' ')
+}

package/lib/{http-error.js → http-error.mjs}

@@ -1,34 +1,35 @@
-module.exports = HTTPError
-
-function HTTPError (status, message) {
-  if (!(this instanceof HTTPError)) {
-    return new HTTPError(status, message)
-  }
-
-  // Error.captureStackTrace(this, this.constructor)
-  this.name = this.constructor.name
-
-  // If status is an object it will be of the form:
-  // {status: , message: }
-  if (typeof status === 'number') {
-    this.message = message || 'Error occurred'
-    this.status = status
-  } else {
-    const err = status
-    let _status
-    let _code
-    let _message
-    if (err && err.status) {
-      _status = err.status
-    }
-    if (err && err.code) {
-      _code = err.code
-    }
-    if (err && err.message) {
-      _message = err.message
-    }
-    this.message = message || _message
-    this.status = _status || _code === 'ENOENT' ? 404 : 500
-  }
-}
-require('util').inherits(module.exports, Error)
+import { inherits } from 'util'
+
+export default function HTTPError (status, message) {
+  if (!(this instanceof HTTPError)) {
+    return new HTTPError(status, message)
+  }
+
+  // Error.captureStackTrace(this, this.constructor)
+  this.name = this.constructor.name
+
+  // If status is an object it will be of the form:
+  // {status: , message: }
+  if (typeof status === 'number') {
+    this.message = message || 'Error occurred'
+    this.status = status
+  } else {
+    const err = status
+    let _status
+    let _code
+    let _message
+    if (err && err.status) {
+      _status = err.status
+    }
+    if (err && err.code) {
+      _code = err.code
+    }
+    if (err && err.message) {
+      _message = err.message
+    }
+    this.message = message || _message
+    this.status = _status || _code === 'ENOENT' ? 404 : 500
+  }
+}
+
+inherits(HTTPError, Error)

package/lib/{ldp-container.js → ldp-container.mjs}

@@ -1,15 +1,13 @@
-module.exports.addContainerStats = addContainerStats
-module.exports.addFile = addFile
-module.exports.addStats = addStats
-module.exports.readdir = readdir
-
-const $rdf = require('rdflib')
-const debug = require('./debug')
-const error = require('./http-error')
-const fs = require('fs')
-const ns = require('solid-namespace')($rdf)
-const mime = require('mime-types')
-const path = require('path')
+import $rdf from 'rdflib'
+import debug from './debug.mjs'
+import error from './http-error.mjs'
+import fs from 'fs'
+import vocab from 'solid-namespace'
+import mime from 'mime-types'
+import path from 'path'
+const ns = vocab($rdf)
+
+export { addContainerStats, addFile, addStats, readdir }
 
 async function addContainerStats (ldp, reqUri, filename, resourceGraph) {
   const containerStats = await ldp.stat(filename)

package/lib/ldp-copy.mjs

@@ -0,0 +1,82 @@
+import debugModule from './debug.mjs'
+import fs from 'fs'
+import { ensureDir } from 'fs-extra'
+import HTTPError from './http-error.mjs'
+import path from 'path'
+import http from 'http'
+import https from 'https'
+import { getContentType } from './utils.mjs'
+
+const debug = debugModule.handlers
+
+/**
+ * Cleans up a file write stream (ends stream, deletes the file).
+ * @method cleanupFileStream
+ * @private
+ * @param stream {WriteStream}
+ */
+function cleanupFileStream (stream) {
+  const streamPath = stream.path
+  stream.destroy()
+  fs.unlinkSync(streamPath)
+}
+
+/**
+ * Performs an LDP Copy operation, imports a remote resource to a local path.
+ * @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
+ * @return A promise resolving when the copy operation is finished
+ */
+export default function copy (resourceMapper, copyToUri, copyFromUri) {
+  return new Promise((resolve, reject) => {
+    const request = /^https:/.test(copyFromUri) ? https : http
+
+    const options = {
+      rejectUnauthorized: false // Allow self-signed certificates for internal requests
+    }
+
+    request.get(copyFromUri, options)
+      .on('error', function (err) {
+        debug('COPY -- Error requesting source file: ' + err)
+        this.end()
+        return reject(new Error('Error writing data: ' + err))
+      })
+      .on('response', function (response) {
+        if (response.statusCode !== 200) {
+          debug('COPY -- HTTP error reading source file: ' + response.statusMessage)
+          this.end()
+          const error = new Error('Error reading source file: ' + response.statusMessage)
+          error.statusCode = response.statusCode
+          return reject(error)
+        }
+        // Grab the content type from the source
+        const contentType = getContentType(response.headers)
+        resourceMapper.mapUrlToFile({ url: copyToUri, createIfNotExists: true, contentType })
+          .then(({ path: copyToPath }) => {
+            ensureDir(path.dirname(copyToPath))
+              .then(() => {
+                const destinationStream = fs.createWriteStream(copyToPath)
+                  .on('error', function (err) {
+                    cleanupFileStream(this)
+                    return reject(new Error('Error writing data: ' + err))
+                  })
+                  .on('finish', function () {
+                    // Success
+                    debug('COPY -- Wrote data to: ' + copyToPath)
+                    resolve()
+                  })
+                response.pipe(destinationStream)
+              })
+              .catch(err => {
+                debug('COPY -- Error creating destination directory: ' + err)
+                return reject(new Error('Failed to create the path to the destination resource: ' + err))
+              })
+          })
+          .catch((err) => {
+            debug('COPY -- mapUrlToFile error: ' + err)
+            reject(HTTPError(500, 'Could not find target file to copy'))
+          })
+      })
+  })
+}

package/lib/ldp-middleware.mjs

@@ -0,0 +1,38 @@
+import express from 'express'
+import { linksHandler, addPermissions } from './header.mjs'
+import allow from './handlers/allow.mjs'
+import get from './handlers/get.mjs'
+import post from './handlers/post.mjs'
+import put from './handlers/put.mjs'
+import del from './handlers/delete.mjs'
+import patch from './handlers/patch.mjs'
+import index from './handlers/index.mjs'
+import copy from './handlers/copy.mjs'
+import notify from './handlers/notify.mjs'
+
+export default function LdpMiddleware (corsSettings, prep) {
+  const router = express.Router('/')
+
+  // Add Link headers
+  router.use(linksHandler)
+
+  if (corsSettings) {
+    router.use(corsSettings)
+  }
+
+  router.copy('/*', allow('Write'), copy)
+  router.get('/*', index, allow('Read'), addPermissions, get)
+  router.post('/*', allow('Append'), post)
+  router.patch('/*', allow('Append'), patch)
+  router.put('/*', allow('Append'), put)
+  router.delete('/*', allow('Write'), del)
+
+  if (prep) {
+    router.post('/*', notify)
+    router.patch('/*', notify)
+    router.put('/*', notify)
+    router.delete('/*', notify)
+  }
+
+  return router
+}