solid-server 5.6.9-beta

package/lib/ldp-container.js

@@ -0,0 +1,161 @@
+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')
+
+async function addContainerStats (ldp, reqUri, filename, resourceGraph) {
+  const containerStats = await ldp.stat(filename)
+  addStats(resourceGraph, reqUri, containerStats, filename)
+  resourceGraph.add(
+    resourceGraph.sym(reqUri),
+    ns.rdf('type'),
+    ns.ldp('BasicContainer'))
+  resourceGraph.add(
+    resourceGraph.sym(reqUri),
+    ns.rdf('type'),
+    ns.ldp('Container'))
+}
+
+async function addFile (ldp, resourceGraph, containerUri, reqUri, container, file) {
+  // Skip .meta and .acl
+  if (file.endsWith(ldp.suffixMeta) || file.endsWith(ldp.suffixAcl)) {
+    return null
+  }
+
+  const filePath = path.join(container, file)
+
+  // Get file stats
+  let stats
+  try {
+    stats = await ldp.stat(filePath)
+  } catch (e) {
+    return null
+  }
+  const memberUri = reqUri + (stats.isDirectory() ? '/' : '')
+
+  // Add fileStats to resource Graph
+  addStats(resourceGraph, memberUri, stats, file)
+
+  // Add to `contains` list
+  resourceGraph.add(
+    resourceGraph.sym(containerUri),
+    ns.ldp('contains'),
+    resourceGraph.sym(memberUri))
+
+  // Set up a metaFile path
+  // Earlier code used a .ttl file as its own meta file, which
+  // caused massive data files to parsed as part of deirectory listings just looking for type triples
+  const metaFile = containerUri + file + ldp.suffixMeta
+
+  let metadataGraph
+  try {
+    metadataGraph = await getMetadataGraph(ldp, metaFile, memberUri)
+  } catch (err) {
+    metadataGraph = $rdf.graph()
+  }
+
+  // Add Container or BasicContainer types
+  if (stats.isDirectory()) {
+    resourceGraph.add(
+      metadataGraph.sym(memberUri),
+      ns.rdf('type'),
+      ns.ldp('BasicContainer'))
+
+    resourceGraph.add(
+      metadataGraph.sym(memberUri),
+      ns.rdf('type'),
+      ns.ldp('Container'))
+  }
+  // Add generic LDP type
+  resourceGraph.add(
+    metadataGraph.sym(memberUri),
+    ns.rdf('type'),
+    ns.ldp('Resource'))
+
+  // Add type from metadataGraph
+  metadataGraph
+    .statementsMatching(
+      metadataGraph.sym(memberUri),
+      ns.rdf('type'),
+      undefined)
+    .forEach(function (typeStatement) {
+      // If the current is a file and its type is BasicContainer,
+      // This is not possible, so do not infer its type!
+      if (
+        (
+          typeStatement.object.uri !== ns.ldp('BasicContainer').uri &&
+          typeStatement.object.uri !== ns.ldp('Container').uri
+        ) ||
+        !stats.isFile()
+      ) {
+        resourceGraph.add(
+          resourceGraph.sym(reqUri),
+          typeStatement.predicate,
+          typeStatement.object)
+      }
+    })
+
+  return null
+}
+
+function addStats (resourceGraph, reqUri, stats, filename) {
+  resourceGraph.add(
+    resourceGraph.sym(reqUri),
+    ns.stat('mtime'), // Deprecate?
+    stats.mtime.getTime() / 1000)
+
+  resourceGraph.add(
+    resourceGraph.sym(reqUri),
+    ns.dct('modified'),
+    stats.mtime) // An actual datetime value from a Date object
+
+  resourceGraph.add(
+    resourceGraph.sym(reqUri),
+    ns.stat('size'),
+    stats.size)
+
+  if (!reqUri.endsWith('/') && mime.lookup(filename)) { // Is the file has a well-known type,
+    const type = 'http://www.w3.org/ns/iana/media-types/' + mime.lookup(filename) + '#Resource'
+    resourceGraph.add(
+      resourceGraph.sym(reqUri),
+      ns.rdf('type'), // convert MIME type to RDF
+      resourceGraph.sym(type)
+    )
+  }
+}
+
+function readdir (filename) {
+  debug.handlers('GET -- Reading directory')
+  return new Promise((resolve, reject) => {
+    fs.readdir(filename, function (err, files) {
+      if (err) {
+        debug.handlers('GET -- Error reading files: ' + err)
+        return reject(error(err, 'Can\'t read container'))
+      }
+
+      debug.handlers('Files in directory: ' + files.toString().slice(0, 100))
+      return resolve(files)
+    })
+  })
+}
+
+async function getMetadataGraph (ldp, metaFile) {
+  const metaStats = await ldp.stat(metaFile)
+  if (metaStats && metaStats.isFile()) {
+    try {
+      return await ldp.getGraph(metaFile)
+    } catch (err) {
+      throw error(err, 'Can\'t parse container metadata')
+    }
+  } else {
+    return $rdf.graph()
+  }
+}

package/lib/ldp-copy.js

@@ -0,0 +1,73 @@
+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).
+ * @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
+ */
+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()
+        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)
+          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 }) => {
+            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')))
+      })
+  })
+}

package/lib/ldp-middleware.js

@@ -0,0 +1,32 @@
+module.exports = LdpMiddleware
+
+const express = require('express')
+const header = require('./header')
+const allow = require('./handlers/allow')
+const get = require('./handlers/get')
+const post = require('./handlers/post')
+const put = require('./handlers/put')
+const del = require('./handlers/delete')
+const patch = require('./handlers/patch')
+const index = require('./handlers/index')
+const copy = require('./handlers/copy')
+
+function LdpMiddleware (corsSettings) {
+  const router = express.Router('/')
+
+  // Add Link headers
+  router.use(header.linksHandler)
+
+  if (corsSettings) {
+    router.use(corsSettings)
+  }
+
+  router.copy('/*', allow('Write'), copy)
+  router.get('/*', index, allow('Read'), header.addPermissions, get)
+  router.post('/*', allow('Append'), post)
+  router.patch('/*', allow('Append'), patch)
+  router.put('/*', allow('Write'), put)
+  router.delete('/*', allow('Write'), del)
+
+  return router
+}