solid-server 5.8.8 → 6.0.0-2a7305e7

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

@@ -1,28 +1,20 @@
-/* eslint-disable node/no-deprecated-api */
-
-const { join, dirname } = require('path')
-const intoStream = require('into-stream')
-const url = require('url')
-const fs = require('fs')
-const $rdf = require('rdflib')
-const mkdirp = require('fs-extra').mkdirp
-const uuid = require('uuid')
-const debug = require('./debug')
-const error = require('./http-error')
-const stringToStream = require('./utils').stringToStream
-const serialize = require('./utils').serialize
-const overQuota = require('./utils').overQuota
-const getContentType = require('./utils').getContentType
-const extend = require('extend')
-const rimraf = require('rimraf')
-const ldpContainer = require('./ldp-container')
-const parse = require('./utils').parse
-const fetch = require('node-fetch')
-const { promisify } = require('util')
-const URL = require('url')
-const withLock = require('./lock')
-const utilPath = require('path')
-const { clearAclCache } = require('./acl-checker')
+import utilPath, { join, dirname } from 'path'
+import intoStream from 'into-stream'
+import urlModule from 'url'
+import fs from 'fs'
+import $rdf from 'rdflib'
+import { mkdirp } from 'fs-extra'
+import { v4 as uuid } from 'uuid' // there seem to be an esm module
+import debug from './debug.mjs'
+import error from './http-error.mjs'
+import { stringToStream, serialize, overQuota, getContentType, parse } from './utils.mjs'
+import extend from 'extend'
+import rimraf from 'rimraf'
+import { exec } from 'child_process'
+import * as ldpContainer from './ldp-container.mjs'
+import { promisify } from 'util'
+import withLock from './lock.mjs'
+import { clearAclCache } from './acl-checker.mjs'
 
 const RDF_MIME_TYPES = new Set([
   'text/turtle', // .ttl
@@ -149,6 +141,7 @@ class LDP {
       extension = ''
     }
     // pepare slug
+    debug.handlers('POST -- Slug: ' + slug) // alain
     if (slug) {
       slug = decodeURIComponent(slug)
 
@@ -170,7 +163,8 @@ class LDP {
     debug.handlers('POST -- Will create at: ' + resourceUrl)
 
     await ldp.put(resourceUrl, stream, contentType)
-    return URL.parse(resourceUrl).path
+    // return urlModule.parse(resourceUrl).path
+    return new URL(resourceUrl).pathname
   }
 
   isAuxResource (slug, extension) {
@@ -200,10 +194,9 @@ class LDP {
    * @return {Promise<Graph>}
    */
   async putGraph (graph, uri, contentType) {
-    const { path } = url.parse(uri)
     const content = await serialize(graph, uri, contentType)
     const stream = stringToStream(content)
-    return await this.put(path, stream, contentType)
+    return await this.put(uri, stream, contentType)
   }
 
   isValidRdf (body, requestUri, contentType) {
@@ -211,7 +204,7 @@ class LDP {
     try {
       $rdf.parse(body, resourceGraph, requestUri, contentType)
     } catch (err) {
-      debug.ldp('VALIDATE -- Error parsing data: ' + err)
+      if (debug && debug.ldp) debug.ldp('VALIDATE -- Error parsing data: ' + err)
       return false
     }
     return true
@@ -225,7 +218,7 @@ class LDP {
         'PUT request requires a content-type via the Content-Type header')
     }
     // reject resource with percent-encoded $ extension
-    const dollarExtensionRegex = /%(?:24)\.[^%(?:24)]*$/ // /\$\.[^$]*$/
+    const dollarExtensionRegex = /%(?:24)\.[^%(?:24)]*$/
     if ((url.url || url).match(dollarExtensionRegex)) {
       throw error(400, 'Resource with a $.ext is not allowed by the server')
     }
@@ -233,7 +226,7 @@ class LDP {
     let isOverQuota
     // Someone had a reason to make url actually a req sometimes but not
     // all the time. So now we have to account for that, as done below.
-    const hostname = typeof url !== 'string' ? url.hostname : URL.parse(url).hostname
+    const hostname = typeof url !== 'string' ? url.hostname : urlModule.parse(url).hostname
     try {
       isOverQuota = await overQuota(this.resourceMapper.resolveFilePath(hostname), this.serverUri)
     } catch (err) {
@@ -251,7 +244,6 @@ class LDP {
     })
 
     if (container) { path += suffixMeta }
-    // debug.handlers(container + ' item ' + (url.url || url) + ' ' + contentType + ' ' + path)
     // check if file exists, and in that case that it has the same extension
     if (!container) { await this.checkFileExtension(url, path) }
     // Create the enclosing directory, if necessary, do not create pubsub if PUT create container
@@ -266,7 +258,7 @@ class LDP {
     return withLock(path, () => new Promise((resolve, reject) => {
       // HACK: the middleware in webid-oidc.js uses body-parser, thus ending the stream of data
       // for JSON bodies. So, the stream needs to be reset
-      if (contentType.includes('application/json')) {
+      if (contentType && contentType.includes && contentType.includes('application/json')) {
         stream = intoStream(JSON.stringify(stream.body))
       }
       const file = stream.pipe(fs.createWriteStream(path))
@@ -288,9 +280,9 @@ class LDP {
    * @param {*} hostname
    * @param {*} nonContainer
    */
-  async createDirectory (path, hostname, nonContainer = true) {
+  async createDirectory (pathArg, hostname, nonContainer = true) {
     try {
-      const dirName = dirname(path)
+      const dirName = dirname(pathArg)
       if (!fs.existsSync(dirName)) {
         await promisify(mkdirp)(dirName)
         if (this.live && nonContainer) {
@@ -303,20 +295,19 @@ class LDP {
             hostname
           })).url
           // Update websockets
-          this.live(URL.parse(parentDirectoryUrl).pathname)
+          this.live(urlModule.parse(parentDirectoryUrl).pathname)
         }
       }
     } catch (err) {
       debug.handlers('PUT -- Error creating directory: ' + err)
-      throw error(err,
-        'Failed to create the path to the new resource')
+      throw error(err, 'Failed to create the path to the new resource')
     }
   }
 
-  async checkFileExtension (url, path) {
+  async checkFileExtension (urlArg, pathArg) {
     try {
-      const { path: existingPath } = await this.resourceMapper.mapUrlToFile({ url })
-      if (path !== existingPath) {
+      const { path: existingPath } = await this.resourceMapper.mapUrlToFile({ url: urlArg })
+      if (pathArg !== existingPath) {
         try {
           await withLock(existingPath, () => promisify(fs.unlink)(existingPath))
         } catch (err) { throw error(err, 'Failed to delete resource') }
@@ -346,7 +337,8 @@ class LDP {
     const container = itemUrl.endsWith('/')
     try {
       const testUrl = container ? itemUrl.slice(0, -1) : itemUrl + '/'
-      const { path: testPath } = await this.resourceMapper.mapUrlToFile({ url: testUrl })
+      const mapped = await this.resourceMapper.mapUrlToFile({ url: testUrl })
+      testPath = mapped.path
       testName = container ? fs.lstatSync(testPath).isFile() : fs.lstatSync(testPath).isDirectory()
     } catch (err) {
       testName = false
@@ -390,11 +382,11 @@ class LDP {
   async fetchGraph (uri, options = {}) {
     const response = await fetch(uri)
     if (!response.ok) {
-      const error = new Error(
+      const err = new Error(
         `Error fetching ${uri}: ${response.status} ${response.statusText}`
       )
-      error.statusCode = response.status || 400
-      throw error
+      err.statusCode = response.status || 400
+      throw err
     }
     const body = await response.text()
 
@@ -402,20 +394,19 @@ class LDP {
   }
 
   /**
-   * Loads from fs the graph at a given uri, parses it and and returns it.
+   * Remotely loads the graph at a given uri, parses it and and returns it.
    * Usage:
    *
    *   ```
-   *   ldp.getGraph('https://localhost:8443/contacts/card1.ttl')
+   *   ldp.fetchGraph('https://example.com/contacts/card1.ttl')
    *     .then(graph => {
-   *       // let matches = graph.match(...)
+   *       // const matches = graph.match(...)
    *     })
    *   ```
    *
    * @param uri {string} Fully qualified uri of the request.
-   *   Note that the protocol part is needed, to provide a base URI to pass on
-   *   to the graph parser.
-   * @param [contentType] {string}
+   *
+   * @param [options] {object} Options hashmap, passed through to fetchGraph
    *
    * @return {Promise<Graph>}
    */
@@ -439,55 +430,47 @@ class LDP {
   // this /.meta has no functionality in actual NSS
   // comment https://github.com/solid/node-solid-server/pull/1604#discussion_r652903546
   async isOwner (webId, hostname) {
-    // const ldp = req.app.locals.ldp
     const rootUrl = this.resourceMapper.resolveUrl(hostname)
     let graph
     try {
-      // TODO check for permission ?? Owner is a MUST
       graph = await this.getGraph(rootUrl + '/.meta')
       const SOLID = $rdf.Namespace('http://www.w3.org/ns/solid/terms#')
       const owner = await graph.statementsMatching($rdf.sym(webId), SOLID('account'), $rdf.sym(rootUrl + '/'))
       return owner.length
     } catch (error) {
-      throw new Error(`Failed to get owner from ${rootUrl}/.meta, got ` + error)
+      throw new Error(`Failed to get owner from ${rootUrl}/.meta, got ` + error, { cause: error })
     }
   }
 
   async get (options, searchIndex = true) {
-    let path, contentType, stats
+    let pathLocal, contentType, stats
     try {
-      ({ path, contentType } = await this.resourceMapper.mapUrlToFile({ url: options, searchIndex }))
-      stats = await this.stat(path)
+      ({ path: pathLocal, contentType } = await this.resourceMapper.mapUrlToFile({ url: options, searchIndex }))
+      stats = await this.stat(pathLocal)
     } catch (err) {
       throw error(err.status || 500, err.message)
     }
 
-    // Just return, since resource exists
     if (!options.includeBody) {
       return { stream: stats, contentType, container: stats.isDirectory() }
     }
 
-    // Found a container
     if (stats.isDirectory()) {
-      const { url: absContainerUri } = await this.resourceMapper
-        .mapFileToUrl({ path, hostname: options.hostname })
-      const metaFile = await this.readContainerMeta(absContainerUri)
-        .catch(() => '') // Default to an empty meta file if it is missing
+      const { url: absContainerUri } = await this.resourceMapper.mapFileToUrl({ path: pathLocal, hostname: options.hostname })
+      const metaFile = await this.readContainerMeta(absContainerUri).catch(() => '')
       let data
       try {
-        data = await this.listContainer(path, absContainerUri, metaFile, options.hostname)
+        data = await this.listContainer(pathLocal, absContainerUri, metaFile, options.hostname)
       } catch (err) {
         debug.handlers('GET container -- Read error:' + err.message)
         throw err
       }
       const stream = stringToStream(data)
-      // TODO contentType is defaultContainerContentType ('text/turtle'),
-      // This forces one translation turtle -> desired
       return { stream, contentType, container: true }
     } else {
       let chunksize, contentRange, start, end
       if (options.range) {
-        const total = fs.statSync(path).size
+        const total = fs.statSync(pathLocal).size
         const parts = options.range.replace(/bytes=/, '').split('-')
         const partialstart = parts[0]
         const partialend = parts[1]
@@ -496,15 +479,15 @@ class LDP {
         chunksize = (end - start) + 1
         contentRange = 'bytes ' + start + '-' + end + '/' + total
       }
-      return withLock(path, () => new Promise((resolve, reject) => {
-        const stream = fs.createReadStream(path, start && end ? { start, end } : {})
+      return withLock(pathLocal, () => new Promise((resolve, reject) => {
+        const stream = fs.createReadStream(pathLocal, start && end ? { start, end } : {})
         stream
           .on('error', function (err) {
-            debug.handlers(`GET -- error reading ${path}: ${err.message}`)
+            debug.handlers(`GET -- error reading ${pathLocal}: ${err.message}`)
             return reject(error(err, "Can't read file " + err))
           })
           .on('open', function () {
-            debug.handlers(`GET -- Reading ${path}`)
+            debug.handlers(`GET -- Reading ${pathLocal}`)
             return resolve({ stream, contentType, container: false, contentRange, chunksize })
           })
       }))
@@ -544,9 +527,7 @@ class LDP {
   }
 
   async deleteContainer (directory) {
-    if (directory[directory.length - 1] !== '/') {
-      directory += '/'
-    }
+    if (directory[directory.length - 1] !== '/') directory += '/'
 
     // Ensure the container exists
     let list
@@ -590,22 +571,245 @@ class LDP {
     }
   }
 
-  async getAvailableUrl (hostname, containerURI, { slug = uuid.v1(), extension, container }) {
+  async copy (from, to, options) {
+    if (overQuota(this.quotaFile, this.quota)) {
+      debug.handlers('COPY -- Over quota')
+      throw error(413, 'Storage quota exceeded')
+    }
+
+    const originalParsedPath = urlModule.parse(from)
+    const parsedPath = urlModule.parse(to)
+    const fromPath = this.resourceMapper.resolveFilePath(
+      originalParsedPath.hostname,
+      decodeURIComponent(originalParsedPath.pathname)
+    )
+    const toPath = this.resourceMapper.resolveFilePath(
+      parsedPath.hostname,
+      decodeURIComponent(parsedPath.pathname)
+    )
+
+    // Check if file already exists
+    if (fs.existsSync(toPath)) {
+      throw error(412, 'Target file already exists')
+    }
+
+    let copyPromise
+
+    // create destination directory if not exists
+    mkdirp(dirname(toPath))
+
+    // If original is a single file
+    if (!fromPath.endsWith('/')) {
+      copyPromise = new Promise((resolve, reject) => {
+        const readStream = fs.createReadStream(fromPath)
+        const writeStream = fs.createWriteStream(toPath)
+        readStream.on('error', function (err) {
+          debug.handlers('Error reading file: ' + err)
+          reject(error(500, err))
+        })
+        writeStream.on('error', function (err) {
+          debug.handlers('Error writing file: ' + err)
+          reject(error(500, err))
+        })
+        writeStream.on('finish', function () {
+          debug.handlers('Finished copying file')
+          resolve()
+        })
+        readStream.pipe(writeStream)
+      })
+    } else {
+      // If original is a folder, copy recursively
+      copyPromise = new Promise((resolve, reject) => {
+        exec(`cp -r "${fromPath}" "${toPath}"`, function (err) {
+          if (err) {
+            debug.handlers('Error copying directory: ' + err)
+            reject(error(500, err))
+          } else {
+            debug.handlers('Finished copying directory')
+            resolve()
+          }
+        })
+      })
+    }
+
+    await copyPromise
+    // Copy ACL file if exists
+    if (fs.existsSync(fromPath + this.suffixAcl)) {
+      const readAclStream = fs.createReadStream(fromPath + this.suffixAcl)
+      const writeAclStream = fs.createWriteStream(toPath + this.suffixAcl)
+      await new Promise((resolve, reject) => {
+        readAclStream.on('error', function (err) {
+          debug.handlers('Error reading ACL file: ' + err)
+          reject(error(500, err))
+        })
+        writeAclStream.on('error', function (err) {
+          debug.handlers('Error writing ACL file: ' + err)
+          reject(error(500, err))
+        })
+        writeAclStream.on('finish', function () {
+          debug.handlers('Finished copying ACL file')
+          resolve()
+        })
+        readAclStream.pipe(writeAclStream)
+      })
+    }
+
+    // Copy meta file if exists
+    if (fs.existsSync(fromPath + this.suffixMeta)) {
+      const readMetaStream = fs.createReadStream(fromPath + this.suffixMeta)
+      const writeMetaStream = fs.createWriteStream(toPath + this.suffixMeta)
+      await new Promise((resolve, reject) => {
+        readMetaStream
+          .on('error', function (err) {
+            debug.handlers('Error reading meta file: ' + err)
+            reject(error(500, err))
+          })
+          .on('open', function () {
+            readMetaStream.pipe(writeMetaStream)
+          })
+        writeMetaStream.on('error', function (err) {
+          debug.handlers('Error writing meta file: ' + err)
+          reject(error(500, err))
+        })
+        writeMetaStream.on('finish', function () {
+          debug.handlers('Finished copying meta file')
+          resolve()
+        })
+      })
+    }
+
+    await clearAclCache()
+
+    debug.handlers('COPY -- Copied ' + fromPath + ' to ' + toPath)
+  }
+
+  async patch (uri, patchObject) {
+    if (overQuota(this.quotaFile, this.quota)) {
+      debug.handlers('PATCH -- Over quota')
+      throw error(413, 'Storage quota exceeded')
+    }
+
+    const url = uri
+    let path
+    try {
+      ({ path } = await this.resourceMapper.mapUrlToFile({ url }))
+    } catch (err) {
+      throw error(err.status || 500, err.message)
+    }
+
+    await withLock(path, async () => {
+      let originalData
+
+      try {
+        originalData = await promisify(fs.readFile)(path, { encoding: 'utf8' })
+      } catch (err) {
+        throw error(err, 'Cannot patch a file that does not exist')
+      }
+
+      const contentType = getContentType(path)
+      const patchedData = await this.applyPatch(originalData, patchObject, contentType, uri)
+
+      // Write patched data back to file
+      await promisify(fs.writeFile)(path, patchedData, 'utf8')
+    })
+
+    await clearAclCache()
+
+    debug.handlers('PATCH -- Patched:' + path)
+  }
+
+  async applyPatch (data, patchObject, contentType, uri) {
+    const baseGraph = $rdf.graph()
+    let patchedGraph
+
+    try {
+      $rdf.parse(data, baseGraph, uri, contentType)
+    } catch (err) {
+      throw error(500, 'Cannot parse file for patching: ' + uri)
+    }
+
+    // Apply patches
+    if (patchObject.updates) {
+      patchedGraph = await this.applyPatchUpdate(baseGraph, patchObject.updates, uri, contentType)
+    } else if (patchObject.deletes || patchObject.inserts) {
+      patchedGraph = await this.applyPatchInsertDelete(baseGraph, patchObject, uri, contentType)
+    } else {
+      throw error(422, 'Invalid patch object')
+    }
+
+    try {
+      return await serialize(patchedGraph, uri, contentType)
+    } catch (err) {
+      throw error(500, 'Cannot serialize patched file: ' + uri)
+    }
+  }
+
+  async applyPatchUpdate (baseGraph, updates, uri, contentType) {
+    const patchedGraph = baseGraph
+
+    for (const update of updates) {
+      if (update.operation === 'delete') {
+        const deleteQuads = this.parseQuads(update.where, uri, contentType)
+        for (const quad of deleteQuads) {
+          patchedGraph.removeMatches(quad.subject, quad.predicate, quad.object)
+        }
+      } else if (update.operation === 'insert') {
+        const insertQuads = this.parseQuads(update.quads, uri, contentType)
+        for (const quad of insertQuads) {
+          patchedGraph.add(quad.subject, quad.predicate, quad.object)
+        }
+      } else {
+        throw error(422, 'Unknown patch operation: ' + update.operation)
+      }
+    }
+
+    return patchedGraph
+  }
+
+  async applyPatchInsertDelete (baseGraph, patchObject, uri, contentType) {
+    const patchedGraph = baseGraph
+
+    // Apply deletes first
+    if (patchObject.deletes) {
+      const deleteQuads = this.parseQuads(patchObject.deletes, uri, contentType)
+      for (const quad of deleteQuads) {
+        patchedGraph.removeMatches(quad.subject, quad.predicate, quad.object)
+      }
+    }
+
+    // Apply inserts
+    if (patchObject.inserts) {
+      const insertQuads = this.parseQuads(patchObject.inserts, uri, contentType)
+      for (const quad of insertQuads) {
+        patchedGraph.add(quad.subject, quad.predicate, quad.object)
+      }
+    }
+
+    return patchedGraph
+  }
+
+  parseQuads (quads, uri, contentType) {
+    const graph = $rdf.graph()
+    $rdf.parse(quads, graph, uri, contentType)
+    return graph.statements
+  }
+
+  async getAvailableUrl (hostname, containerURI, { slug = uuid(), extension, container } = {}) {
     let requestUrl = this.resourceMapper.resolveUrl(hostname, containerURI)
-    requestUrl = requestUrl.replace(/\/*$/, '/') // ??? what for
+    requestUrl = requestUrl.replace(/\/*$/, '/')
 
     let itemName = slug.endsWith(extension) || slug.endsWith(this.suffixAcl) || slug.endsWith(this.suffixMeta) ? slug : slug + extension
     try {
       // check whether resource exists
       const context = container ? '/' : ''
       await this.resourceMapper.mapUrlToFile({ url: (requestUrl + itemName + context) })
-      itemName = `${uuid.v1()}-${itemName}`
+      itemName = `${uuid()}-${itemName}`
     } catch (e) {
       try {
         // check whether resource with same name exists
         const context = !container ? '/' : ''
         await this.resourceMapper.mapUrlToFile({ url: (requestUrl + itemName + context) })
-        itemName = `${uuid.v1()}-${itemName}`
+        itemName = `${uuid()}-${itemName}`
       } catch (e) {}
     }
     if (container) itemName += '/'
@@ -620,6 +824,10 @@ class LDP {
     return trustedOrigins
   }
 
+  static getRDFMimeTypes () {
+    return Array.from(RDF_MIME_TYPES)
+  }
+
   static mimeTypeIsRdf (mimeType) {
     return RDF_MIME_TYPES.has(mimeType)
   }
@@ -628,4 +836,5 @@ class LDP {
     return Array.from(RDF_MIME_TYPES)
   }
 }
-module.exports = LDP
+
+export default LDP

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

@@ -1,10 +1,10 @@
-const AsyncLock = require('async-lock')
-
-const lock = new AsyncLock({ timeout: 30 * 1000 })
-
-// Obtains a lock on the path, and maintains it until the task finishes
-async function withLock (path, executeTask) {
-  return await lock.acquire(path, executeTask)
-}
-
-module.exports = withLock
+import AsyncLock from 'async-lock'
+
+const lock = new AsyncLock({ timeout: 30 * 1000 })
+
+// Obtains a lock on the path, and maintains it until the task finishes
+async function withLock (path, executeTask) {
+  return await lock.acquire(path, executeTask)
+}
+
+export default withLock

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

@@ -1,11 +1,11 @@
-exports.Metadata = Metadata
-
-function Metadata () {
-  this.filename = ''
-  this.isResource = false
-  this.isSourceResource = false
-  this.isContainer = false
-  this.isBasicContainer = false
-  this.isDirectContainer = false
-  this.isStorage = false
-}
+export function Metadata () {
+  this.filename = ''
+  this.isResource = false
+  this.isSourceResource = false
+  this.isContainer = false
+  this.isBasicContainer = false
+  this.isDirectContainer = false
+  this.isStorage = false
+}
+
+export default { Metadata }