missing content in ldp.mjs

Author: CI Fix

lib/ldp.mjs

@@ -1,23 +1,21 @@
 /* eslint-disable node/no-deprecated-api */
 
 import { join, dirname } from 'path'
-import { createRequire } from 'module'
-const require = createRequire(import.meta.url)
-const intoStream = require('into-stream')
+import intoStream from 'into-stream'
 import url from 'url'
 import fs from 'fs'
 import $rdf from 'rdflib'
-const { mkdirp } = require('fs-extra')
+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'
-const extend = require('extend')
-const rimraf = require('rimraf')
+import extend from 'extend'
+import rimraf from 'rimraf'
+import { exec } from 'child_process'
 import * as ldpContainer from './ldp-container.mjs'
 import fetch from 'node-fetch'
 import { promisify } from 'util'
-import URL from 'url'
 import withLock from './lock.mjs'
 import utilPath from 'path'
 import { clearAclCache } from './acl-checker.mjs'
@@ -413,7 +411,6 @@ class LDP {
     } else {
       // If original is a folder, copy recursively
       copyPromise = new Promise((resolve, reject) => {
-        const { exec } = require('child_process')
         exec(`cp -r "${fromPath}" "${toPath}"`, function (err) {
           if (err) {
             debug.handlers('Error copying directory: ' + err)
@@ -598,9 +595,214 @@ class LDP {
     }
   }
 
+  async graph (url, baseUri, contentType) {
+    const body = await this.readResource(url)
+    if (!contentType) {
+      ({ contentType } = await this.resourceMapper.mapUrlToFile({ url }))
+    }
+    return new Promise((resolve, reject) => {
+      const graph = $rdf.graph()
+      $rdf.parse(body, graph, baseUri, contentType,
+        err => err ? reject(err) : resolve(graph))
+    })
+  }
+
   static getRDFMimeTypes () {
     return Array.from(RDF_MIME_TYPES)
   }
+
+  getTrustedOrigins (req) {
+    const trustedOrigins = [this.resourceMapper.resolveUrl(req.hostname)].concat(this.trustedOrigins)
+    if (this.multiuser) {
+      trustedOrigins.push(this.serverUri)
+    }
+    return trustedOrigins
+  }
+
+  async getAvailableUrl (hostname, containerURI, { slug = uuid(), extension, container } = {}) {
+    let requestUrl = this.resourceMapper.resolveUrl(hostname, containerURI)
+    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()}-${itemName}`
+    } catch (e) {
+      try {
+        // check whether resource with same name exists
+        const context = !container ? '/' : ''
+        await this.resourceMapper.mapUrlToFile({ url: (requestUrl + itemName + context) })
+        itemName = `${uuid()}-${itemName}`
+      } catch (e) {}
+    }
+    if (container) itemName += '/'
+    return requestUrl + itemName
+  }
+
+  async exists (hostname, path, searchIndex = true) {
+    const options = { hostname, path, includeBody: false, searchIndex }
+    return await this.get(options, searchIndex)
+  }
+
+  async fetchGraph (uri, options = {}) {
+    const response = await fetch(uri)
+    if (!response.ok) {
+      const err = new Error(
+        `Error fetching ${uri}: ${response.status} ${response.statusText}`
+      )
+      err.statusCode = response.status || 400
+      throw err
+    }
+    const body = await response.text()
+
+    return parse(body, uri, getContentType(response.headers))
+  }
+
+  async checkItemName (url) {
+    let testName, testPath
+    const { hostname, pathname } = this.resourceMapper._parseUrl(url)
+    let itemUrl = this.resourceMapper.resolveUrl(hostname, pathname)
+    if (this._containsInvalidSuffixes(itemUrl)) {
+      throw error(400, `${itemUrl} contained reserved suffixes in path`)
+    }
+    const container = itemUrl.endsWith('/')
+    try {
+      const testUrl = container ? itemUrl.slice(0, -1) : itemUrl + '/'
+      const { path: testPathLocal } = await this.resourceMapper.mapUrlToFile({ url: testUrl })
+      testPath = testPathLocal
+      testName = container ? fs.lstatSync(testPath).isFile() : fs.lstatSync(testPath).isDirectory()
+    } catch (err) {
+      testName = false
+
+      if (itemUrl.endsWith('/')) itemUrl = itemUrl.substring(0, itemUrl.length - 1)
+      itemUrl = itemUrl.substring(0, itemUrl.lastIndexOf('/') + 1)
+      const { pathname: parentPathname } = this.resourceMapper._parseUrl(itemUrl)
+      if (parentPathname !== '/') {
+        return await this.checkItemName(itemUrl)
+      }
+    }
+    if (testName) {
+      throw error(409, `${testPath}: Container and resource cannot have the same name in URI`)
+    }
+  }
+
+  async createDirectory (pathArg, hostname, nonContainer = true) {
+    try {
+      const dirName = dirname(pathArg)
+      if (!fs.existsSync(dirName)) {
+        await promisify(mkdirp)(dirName)
+        if (this.live && nonContainer) {
+          const parentDirectoryPath = utilPath.dirname(dirName) + utilPath.sep
+          const parentDirectoryUrl = (await this.resourceMapper.mapFileToUrl({ path: parentDirectoryPath, hostname })).url
+          this.live(url.parse(parentDirectoryUrl).pathname)
+        }
+      }
+    } catch (err) {
+      debug.handlers('PUT -- Error creating directory: ' + err)
+      throw error(err, 'Failed to create the path to the new resource')
+    }
+  }
+
+  async checkFileExtension (urlArg, pathArg) {
+    try {
+      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') }
+      }
+    } catch (err) { }
+  }
+
+  async deleteContainer (directory) {
+    if (directory[directory.length - 1] !== '/') directory += '/'
+    let list
+    try {
+      list = await promisify(fs.readdir)(directory)
+    } catch (err) {
+      throw error(404, 'The container does not exist')
+    }
+    if (list.some(file => !file.endsWith(this.suffixMeta) && !file.endsWith(this.suffixAcl))) {
+      throw error(409, 'Container is not empty')
+    }
+    try {
+      await promisify(rimraf)(directory)
+    } catch (err) {
+      throw error(err, 'Failed to delete the container')
+    }
+  }
+
+  async deleteDocument (filePath) {
+    const linkPath = this.resourceMapper._removeDollarExtension(filePath)
+    try {
+      await withLock(filePath, () => promisify(fs.unlink)(filePath))
+      const aclPath = `${linkPath}${this.suffixAcl}`
+      if (await promisify(fs.exists)(aclPath)) {
+        await withLock(aclPath, () => promisify(fs.unlink)(aclPath))
+      }
+      const metaPath = `${linkPath}${this.suffixMeta}`
+      if (await promisify(fs.exists)(metaPath)) {
+        await withLock(metaPath, () => promisify(fs.unlink)(metaPath))
+      }
+    } catch (err) {
+      debug.container('DELETE -- unlink() error: ' + err)
+      throw error(err, 'Failed to delete resource')
+    }
+  }
+
+  async get (options, searchIndex = true) {
+    let pathLocal, contentType, stats
+    try {
+      ({ path: pathLocal, contentType } = await this.resourceMapper.mapUrlToFile({ url: options, searchIndex }))
+      stats = await this.stat(pathLocal)
+    } catch (err) {
+      throw error(err.status || 500, err.message)
+    }
+
+    if (!options.includeBody) {
+      return { stream: stats, contentType, container: stats.isDirectory() }
+    }
+
+    if (stats.isDirectory()) {
+      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(pathLocal, absContainerUri, metaFile, options.hostname)
+      } catch (err) {
+        debug.handlers('GET container -- Read error:' + err.message)
+        throw err
+      }
+      const stream = stringToStream(data)
+      return { stream, contentType, container: true }
+    } else {
+      let chunksize, contentRange, start, end
+      if (options.range) {
+        const total = fs.statSync(pathLocal).size
+        const parts = options.range.replace(/bytes=/, '').split('-')
+        const partialstart = parts[0]
+        const partialend = parts[1]
+        start = parseInt(partialstart, 10)
+        end = partialend ? parseInt(partialend, 10) : total - 1
+        chunksize = (end - start) + 1
+        contentRange = 'bytes ' + start + '-' + end + '/' + total
+      }
+      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 ${pathLocal}: ${err.message}`)
+            return reject(error(err, "Can't read file " + err))
+          })
+          .on('open', function () {
+            debug.handlers(`GET -- Reading ${pathLocal}`)
+            return resolve({ stream, contentType, container: false, contentRange, chunksize })
+          })
+      }))
+    }
+  }
 }
 
 export default LDP

test-esm/unit/getAvailableUrl-test.mjs

@@ -0,0 +1,30 @@
+import { strict as assert } from 'assert'
+import LDP from '../../lib/ldp.mjs'
+
+export async function test_noExistingResource() {
+  const rm = {
+    resolveUrl: (hostname, containerURI) => `https://${hostname}/root${containerURI}/`,
+    mapUrlToFile: async () => { throw new Error('Not found') }
+  }
+  const ldp = new LDP({ resourceMapper: rm })
+  const url = await ldp.getAvailableUrl('host.test', '/container', { slug: 'name.txt', extension: '', container: false })
+  assert.equal(url, 'https://host.test/root/container/name.txt')
+}
+
+export async function test_existingResourcePrefixes() {
+  let called = 0
+  const rm = {
+    resolveUrl: (hostname, containerURI) => `https://${hostname}/root${containerURI}/`,
+    mapUrlToFile: async () => {
+      called += 1
+      // First call indicates file exists (resolve), so return some object
+      if (called === 1) return { path: '/some/path' }
+      // Subsequent calls simulate not found
+      throw new Error('Not found')
+    }
+  }
+  const ldp = new LDP({ resourceMapper: rm })
+  const url = await ldp.getAvailableUrl('host.test', '/container', { slug: 'name.txt', extension: '', container: false })
+  // Should contain a uuid-prefix before name.txt, i.e. -name.txt
+  assert.ok(url.endsWith('-name.txt') || url.includes('-name.txt'))
+}

test-esm/unit/getTrustedOrigins-test.mjs

@@ -0,0 +1,20 @@
+import { describe, it } from 'mocha'
+import { assert } from 'chai'
+import LDP from '../../lib/ldp.mjs'
+
+describe('LDP.getTrustedOrigins', () => {
+  it('includes resourceMapper.resolveUrl(hostname), trustedOrigins and serverUri when multiuser', () => {
+    const rm = { resolveUrl: (hostname) => `https://${hostname}/` }
+    const ldp = new LDP({ resourceMapper: rm, trustedOrigins: ['https://trusted.example/'], multiuser: true, serverUri: 'https://server.example/' })
+    const res = ldp.getTrustedOrigins({ hostname: 'host.test' })
+    assert.includeMembers(res, ['https://host.test/', 'https://trusted.example/', 'https://server.example/'])
+  })
+
+  it('omits serverUri when not multiuser', () => {
+    const rm = { resolveUrl: (hostname) => `https://${hostname}/` }
+    const ldp = new LDP({ resourceMapper: rm, trustedOrigins: ['https://trusted.example/'], multiuser: false, serverUri: 'https://server.example/' })
+    const res = ldp.getTrustedOrigins({ hostname: 'host.test' })
+    assert.includeMembers(res, ['https://host.test/', 'https://trusted.example/'])
+    assert.notInclude(res, 'https://server.example/')
+  })
+})

test-esm/unit/ldp-api-test.mjs

@@ -0,0 +1,17 @@
+import { describe, it } from 'mocha'
+import { assert } from 'chai'
+import LDP from '../../lib/ldp.mjs'
+
+describe('LDP ESM API', () => {
+  it('exports expected methods', () => {
+    const proto = LDP.prototype
+    const expected = [
+      'stat', 'readResource', 'readContainerMeta', 'listContainer', 'post', 'put', 'putResource', 'putValidateData',
+      'delete', 'copy', 'patch', 'applyPatch', 'applyPatchUpdate', 'applyPatchInsertDelete', 'parseQuads',
+      'getGraph', 'graph', 'getAvailableUrl', 'getTrustedOrigins', 'exists', 'get'
+    ]
+    expected.forEach(fn => {
+      assert.strictEqual(typeof proto[fn], 'function', `Missing method ${fn}`)
+    })
+  })
+})