solid-server 5.8.6 → 5.8.8-22f4cfec

package/test/utils/index.mjs

@@ -0,0 +1,167 @@
+import fs from 'fs-extra'
+import rimraf from 'rimraf'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import OIDCProvider from '@solid/oidc-op'
+import dns from 'dns'
+import ldnode from '../../index.mjs'
+import supertest from 'supertest'
+import fetch from 'node-fetch'
+import https from 'https'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+const TEST_HOSTS = ['nic.localhost', 'tim.localhost', 'nicola.localhost']
+
+export function rm (file) {
+  return rimraf.sync(path.normalize(path.join(__dirname, '../resources/' + file)))
+}
+
+export function cleanDir (dirPath) {
+  fs.removeSync(path.normalize(path.join(dirPath, '.well-known/.acl')))
+  fs.removeSync(path.normalize(path.join(dirPath, '.acl')))
+  fs.removeSync(path.normalize(path.join(dirPath, 'favicon.ico')))
+  fs.removeSync(path.normalize(path.join(dirPath, 'favicon.ico.acl')))
+  fs.removeSync(path.normalize(path.join(dirPath, 'index.html')))
+  fs.removeSync(path.normalize(path.join(dirPath, 'index.html.acl')))
+  fs.removeSync(path.normalize(path.join(dirPath, 'robots.txt')))
+  fs.removeSync(path.normalize(path.join(dirPath, 'robots.txt.acl')))
+}
+
+export function write (text, file) {
+  return fs.writeFileSync(path.normalize(path.join(__dirname, '../resources/' + file)), text)
+}
+
+export function cp (src, dest) {
+  return fs.copySync(
+    path.normalize(path.join(__dirname, '../resources/' + src)),
+    path.normalize(path.join(__dirname, '../resources/' + dest)))
+}
+
+export function read (file) {
+  return fs.readFileSync(path.normalize(path.join(__dirname, '../resources/' + file)), {
+    encoding: 'utf8'
+  })
+}
+
+// Backs up the given file
+export function backup (src) {
+  cp(src, src + '.bak')
+}
+
+// Restores a backup of the given file
+export function restore (src) {
+  cp(src + '.bak', src)
+  rm(src + '.bak')
+}
+
+// Verifies that all HOSTS entries are present
+export function checkDnsSettings () {
+  return Promise.all(TEST_HOSTS.map(hostname => {
+    return new Promise((resolve, reject) => {
+      dns.lookup(hostname, (error, ip) => {
+        if (error || (ip !== '127.0.0.1' && ip !== '::1')) {
+          reject(error)
+        } else {
+          resolve(true)
+        }
+      })
+    })
+  }))
+    .catch(() => {
+      throw new Error(`Expected HOSTS entries of 127.0.0.1 for ${TEST_HOSTS.join()}`)
+    })
+}
+
+/**
+ * @param configPath {string}
+ *
+ * @returns {Promise<Provider>}
+ */
+export function loadProvider (configPath) {
+  return Promise.resolve()
+    .then(async () => {
+      const { default: config } = await import(configPath)
+
+      const provider = new OIDCProvider(config)
+
+      return provider.initializeKeyChain(config.keys)
+    })
+}
+
+export { createServer }
+function createServer (options) {
+  return ldnode.createServer(options)
+}
+
+export { setupSupertestServer }
+function setupSupertestServer (options) {
+  const ldpServer = createServer(options)
+  return supertest(ldpServer)
+}
+
+// Lightweight adapter to replace `request` with `node-fetch` in tests
+// Supports signatures:
+//  - request(options, cb)
+//  - request(url, options, cb)
+// And methods: get, post, put, patch, head, delete, del
+function buildAgentFn (options = {}) {
+  const aOpts = options.agentOptions || {}
+  if (!aOpts || (!aOpts.cert && !aOpts.key)) {
+    return undefined
+  }
+  const httpsAgent = new https.Agent({
+    cert: aOpts.cert,
+    key: aOpts.key,
+    // Tests often run with NODE_TLS_REJECT_UNAUTHORIZED=0; mirror that here
+    rejectUnauthorized: false
+  })
+  return (parsedURL) => parsedURL.protocol === 'https:' ? httpsAgent : undefined
+}
+
+async function doFetch (method, url, options = {}, cb) {
+  try {
+    const headers = options.headers || {}
+    const body = options.body
+    const agent = buildAgentFn(options)
+    const res = await fetch(url, { method, headers, body, agent })
+    // Build a response object similar to `request`'s
+    const headersObj = {}
+    res.headers.forEach((value, key) => { headersObj[key] = value })
+    const response = {
+      statusCode: res.status,
+      statusMessage: res.statusText,
+      headers: headersObj
+    }
+    const hasBody = method !== 'HEAD'
+    const text = hasBody ? await res.text() : ''
+    cb(null, response, text)
+  } catch (err) {
+    cb(err)
+  }
+}
+
+function requestAdapter (arg1, arg2, arg3) {
+  let url, options, cb
+  if (typeof arg1 === 'string') {
+    url = arg1
+    options = arg2 || {}
+    cb = arg3
+  } else {
+    options = arg1 || {}
+    url = options.url
+    cb = arg2
+  }
+  const method = (options && options.method) || 'GET'
+  return doFetch(method, url, options, cb)
+}
+
+;['GET', 'POST', 'PUT', 'PATCH', 'HEAD', 'DELETE'].forEach(m => {
+  const name = m.toLowerCase()
+  requestAdapter[name] = (options, cb) => doFetch(m, options.url, options, cb)
+})
+// Alias
+requestAdapter.del = requestAdapter.delete
+
+export const httpRequest = requestAdapter

package/test/utils.mjs

@@ -0,0 +1,205 @@
+// import fs from 'fs-extra' // see fs-extra/esm and fs-extra doc
+
+import fs from 'fs'
+import path from 'path'
+import dns from 'dns'
+import https from 'https'
+import { createRequire } from 'module'
+import fetch from 'node-fetch'
+import rimraf from 'rimraf'
+import fse from 'fs-extra'
+import Provider from '@solid/oidc-op'
+import supertest from 'supertest'
+import ldnode from '../index.mjs'
+import { fileURLToPath } from 'url'
+
+const require = createRequire(import.meta.url)
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+const OIDCProvider = Provider
+
+const TEST_HOSTS = ['nic.localhost', 'tim.localhost', 'nicola.localhost']
+
+// Configurable test root directory
+// For custom route
+let TEST_ROOT = path.join(__dirname, '/resources/')
+// For default root (process.cwd()):
+// let TEST_ROOT = path.join(process.cwd(), 'test-esm/resources')
+
+export function setTestRoot (rootPath) {
+  TEST_ROOT = rootPath
+}
+export function getTestRoot () {
+  return TEST_ROOT
+}
+
+export function rm (file) {
+  return rimraf.sync(path.join(TEST_ROOT, file))
+}
+
+export function cleanDir (dirPath) {
+  fse.removeSync(path.join(dirPath, '.well-known/.acl'))
+  fse.removeSync(path.join(dirPath, '.acl'))
+  fse.removeSync(path.join(dirPath, 'favicon.ico'))
+  fse.removeSync(path.join(dirPath, 'favicon.ico.acl'))
+  fse.removeSync(path.join(dirPath, 'index.html'))
+  fse.removeSync(path.join(dirPath, 'index.html.acl'))
+  fse.removeSync(path.join(dirPath, 'robots.txt'))
+  fse.removeSync(path.join(dirPath, 'robots.txt.acl'))
+}
+
+export function write (text, file) {
+  console.log('Writing to', path.join(TEST_ROOT, file))
+  // fs.mkdirSync(path.dirname(path.join(TEST_ROOT, file), { recursive: true }))
+  return fs.writeFileSync(path.join(TEST_ROOT, file), text)
+}
+
+export function cp (src, dest) {
+  return fse.copySync(
+    path.join(TEST_ROOT, src),
+    path.join(TEST_ROOT, dest))
+}
+
+export function read (file) {
+  console.log('Reading from', path.join(TEST_ROOT, file))
+  return fs.readFileSync(path.join(TEST_ROOT, file), {
+    encoding: 'utf8'
+  })
+}
+
+// Backs up the given file
+export function backup (src) {
+  cp(src, src + '.bak')
+}
+
+// Restores a backup of the given file
+export function restore (src) {
+  cp(src + '.bak', src)
+  rm(src + '.bak')
+}
+
+// Verifies that all HOSTS entries are present
+export function checkDnsSettings () {
+  return Promise.all(TEST_HOSTS.map(hostname => {
+    return new Promise((resolve, reject) => {
+      dns.lookup(hostname, (error, ip) => {
+        if (error || (ip !== '127.0.0.1' && ip !== '::1')) {
+          reject(error)
+        } else {
+          resolve(true)
+        }
+      })
+    })
+  }))
+    .catch(() => {
+      throw new Error(`Expected HOSTS entries of 127.0.0.1 for ${TEST_HOSTS.join()}`)
+    })
+}
+
+/**
+ * @param configPath {string}
+ *
+ * @returns {Promise<Provider>}
+ */
+export function loadProvider (configPath) {
+  return Promise.resolve()
+    .then(() => {
+      const config = require(configPath)
+
+      const provider = new OIDCProvider(config)
+
+      return provider.initializeKeyChain(config.keys)
+    })
+}
+
+export function createServer (options) {
+  console.log('Creating server with root:', options.root || process.cwd())
+  return ldnode.createServer(options)
+}
+
+export function setupSupertestServer (options) {
+  const ldpServer = createServer(options)
+  return supertest(ldpServer)
+}
+
+// Lightweight adapter to replace `request` with `node-fetch` in tests
+// Supports signatures:
+//  - request(options, cb)
+//  - request(url, options, cb)
+// And methods: get, post, put, patch, head, delete, del
+function buildAgentFn (options = {}) {
+  const aOpts = options.agentOptions || {}
+  if (!aOpts || (!aOpts.cert && !aOpts.key)) {
+    return undefined
+  }
+  const httpsAgent = new https.Agent({
+    cert: aOpts.cert,
+    key: aOpts.key,
+    // Tests often run with NODE_TLS_REJECT_UNAUTHORIZED=0; mirror that here
+    rejectUnauthorized: false
+  })
+  return (parsedURL) => parsedURL.protocol === 'https:' ? httpsAgent : undefined
+}
+
+async function doFetch (method, url, options = {}, cb) {
+  try {
+    const headers = options.headers || {}
+    const body = options.body
+    const agent = buildAgentFn(options)
+    const res = await fetch(url, { method, headers, body, agent })
+    // Build a response object similar to `request`'s
+    const headersObj = {}
+    res.headers.forEach((value, key) => { headersObj[key] = value })
+    const response = {
+      statusCode: res.status,
+      statusMessage: res.statusText,
+      headers: headersObj
+    }
+    const hasBody = method !== 'HEAD'
+    const text = hasBody ? await res.text() : ''
+    cb(null, response, text)
+  } catch (err) {
+    cb(err)
+  }
+}
+
+function requestAdapter (arg1, arg2, arg3) {
+  let url, options, cb
+  if (typeof arg1 === 'string') {
+    url = arg1
+    options = arg2 || {}
+    cb = arg3
+  } else {
+    options = arg1 || {}
+    url = options.url
+    cb = arg2
+  }
+  const method = (options && options.method) || 'GET'
+  return doFetch(method, url, options, cb)
+}
+
+;['GET', 'POST', 'PUT', 'PATCH', 'HEAD', 'DELETE'].forEach(m => {
+  const name = m.toLowerCase()
+  requestAdapter[name] = (options, cb) => doFetch(m, options.url, options, cb)
+})
+// Alias
+requestAdapter.del = requestAdapter.delete
+
+export const httpRequest = requestAdapter
+
+// Provide default export for compatibility
+export default {
+  rm,
+  cleanDir,
+  write,
+  cp,
+  read,
+  backup,
+  restore,
+  checkDnsSettings,
+  loadProvider,
+  createServer,
+  setupSupertestServer,
+  httpRequest
+}

package/test/validate-turtle.mjs

@@ -0,0 +1,43 @@
+
+import { fileURLToPath } from 'url'
+import fs from 'node:fs'
+import Handlebars from 'handlebars'
+import path from 'node:path'
+import validateModule from 'turtle-validator/lib/validator.js'
+
+const validate = validateModule.default || validateModule
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+const regex = /\\.(acl|ttl)$/i
+const substitutions = {
+  webId: 'http://example.com/#me',
+  email: 'test@example.com',
+  name: 'Test test'
+}
+
+const files = recursiveFiles(path.join(__dirname, '../default-templates/'))
+
+for (const file of files) {
+  const data = fs.readFileSync(file, 'utf8')
+  const template = Handlebars.compile(data)
+  validate(template(substitutions), feedback => {
+    if (feedback.errors.length > 0) {
+      throw new Error(`Validation error in ${file}: ${feedback.errors[0]}`)
+    }
+  })
+}
+
+function recursiveFiles (dir) {
+  const content = fs.readdirSync(dir)
+  return [].concat(...content.map(file => {
+    const fullPath = path.join(dir, file)
+    const stat = fs.statSync(fullPath)
+    if (stat.isDirectory()) {
+      return recursiveFiles(fullPath)
+    } else if (regex.test(file)) {
+      return [fullPath]
+    }
+    return []
+  }))
+}

package/.github/workflows/ci.yml

@@ -1,113 +0,0 @@
-# This workflow will do a clean install of node dependencies, build the source code and run tests across different versions of node
-# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
-
-name: CI
-
-on:
-  push:
-    branches: [ main ]
-    tags: ['*']
-  pull_request:
-    branches: [ main ]
-
-jobs:
-  build:
-
-    runs-on: ${{ matrix.os }}
-
-    strategy:
-      matrix:
-        node-version: [ '^22.14.0' ]
-        os: [ubuntu-latest]
-
-    steps:
-    - uses: actions/checkout@v4
-
-    # extract repository name
-    - if: github.event_name == 'pull_request'
-      run: echo "REPO_NAME=${{ github.event.pull_request.head.repo.full_name }}" >> $GITHUB_ENV
-
-    - if: github.event_name != 'pull_request'
-      run: echo "REPO_NAME=${GITHUB_REPOSITORY}" >> $GITHUB_ENV
-
-    # extract branch name
-    - if: github.event_name == 'pull_request'
-      run: echo "BRANCH_NAME=${GITHUB_HEAD_REF}" >> $GITHUB_ENV
-
-    - if: github.event_name != 'pull_request'
-      run: echo "BRANCH_NAME=${GITHUB_REF#refs/heads/}" >> $GITHUB_ENV
-
-    # print repository name
-    - name: Get repository name
-      run: echo 'The repository name is' $REPO_NAME
-
-    # print branch name
-    - name: Get branch name
-      run: echo 'The branch name is' $BRANCH_NAME
-
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v1
-      with:
-        node-version: ${{ matrix.node-version }}
-    - run: npm ci
-    # test code
-    - run: npm run standard
-    - run: npm run validate
-    - run: npm run nyc
-    # Test global install of the package
-    - run: npm pack .
-    - run: npm install -g solid-server-*.tgz
-    # Run the Solid test-suite
-    - run: bash test/surface/run-solid-test-suite.sh $BRANCH_NAME $REPO_NAME
-
-  # TODO: The pipeline should automate publication to npm, so that the docker build gets the correct version
-  #       This job will only dockerize solid-server@latest / solid-server@<tag-name> from npmjs.com!
-  docker-hub:
-    needs: build
-    name: Publish to docker hub
-    if: github.event_name != 'pull_request'
-    runs-on: ubuntu-latest
-    steps:
-
-      - uses: actions/checkout@v4
-
-      - uses: olegtarasov/get-tag@v2.1
-        id: tagName
-        with:
-          tagRegex: "v?(?<version>.*)"
-
-      - name: Lint dockerfile
-        working-directory: docker-image
-        run: pwd && ls -lah && make lint
-
-      - name: Run tests
-        working-directory: docker-image
-        run: SOLID_SERVER_VERSION=${{ steps.tagName.outputs.version }} make test
-
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v1
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v1
-
-      - name: Docker meta
-        id: meta
-        uses: docker/metadata-action@v3
-        with:
-          images: nodesolidserver/node-solid-server
-
-      - name: Login to DockerHub
-        uses: docker/login-action@v1
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-      - name: Build and push
-        id: docker_build
-        uses: docker/build-push-action@v2
-        with:
-          context: ./docker-image/src
-          build-args: SOLID_SERVER_VERSION=${{ steps.tagName.outputs.version }}
-          push: true
-          tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}

package/.nvmrc

@@ -1 +0,0 @@
-v18.19.0

package/.snyk

@@ -1,35 +0,0 @@
-# Snyk (https://snyk.io) policy file, patches or ignores known vulnerabilities.
-version: v1.12.0
-# ignores vulnerabilities until expiry date; change duration by modifying expiry date
-ignore:
-  'npm:braces:20180219':
-    - http-proxy-middleware > micromatch > braces:
-        reason: None given
-        expires: '2018-09-11T01:52:14.022Z'
-  'npm:node-forge:20180226':
-    - node-forge:
-        reason: None given
-        expires: '2018-09-11T01:52:14.022Z'
-    - webid > node-forge:
-        reason: None given
-        expires: '2018-09-11T01:52:14.023Z'
-  'npm:base64url:20180511':
-    - rdflib > solid-auth-client > @trust/oidc-rp > base64url:
-        reason: None given
-        expires: '2018-09-11T01:52:14.023Z'
-    - rdflib > solid-auth-client > @trust/oidc-rp > @trust/webcrypto > base64url:
-        reason: None given
-        expires: '2018-09-11T01:52:14.023Z'
-    - oidc-auth-manager > rdflib > solid-auth-client > @trust/oidc-rp > base64url:
-        reason: None given
-        expires: '2018-09-11T01:52:14.023Z'
-    - oidc-auth-manager > rdflib > solid-auth-client > @trust/oidc-rp > @trust/webcrypto > base64url:
-        reason: None given
-        expires: '2018-09-11T01:52:14.023Z'
-    - solid-auth-client@2.1.0 > @trust/oidc-rp@0.4.3 > base64url@2.0.0:
-        reason: None given
-        expires: '2018-09-11T01:52:14.023Z'
-    - solid-auth-client@2.1.0 > @trust/oidc-rp@0.4.3 > @trust/webcrypto@0.4.0 > base64url@2.0.0:
-        reason: None given
-        expires: '2018-09-11T01:52:14.023Z'
-patch: {}

package/bin/lib/cli-utils.js

@@ -1,85 +0,0 @@
-const fs = require('fs-extra')
-const { red, cyan, bold } = require('colorette')
-const { URL } = require('url')
-const LDP = require('../../lib/ldp')
-const AccountManager = require('../../lib/models/account-manager')
-const SolidHost = require('../../lib/models/solid-host')
-
-module.exports.getAccountManager = getAccountManager
-module.exports.loadAccounts = loadAccounts
-module.exports.loadConfig = loadConfig
-module.exports.loadUsernames = loadUsernames
-
-/**
- * Returns an instance of AccountManager
- *
- * @param {Object} config
- * @param {Object} [options]
- * @returns {AccountManager}
- */
-function getAccountManager (config, options = {}) {
-  const ldp = options.ldp || new LDP(config)
-  const host = options.host || SolidHost.from({ port: config.port, serverUri: config.serverUri })
-  return AccountManager.from({
-    host,
-    store: ldp,
-    multiuser: config.multiuser
-  })
-}
-
-function loadConfig (program, options) {
-  let argv = {
-    ...options,
-    version: program.version()
-  }
-  const configFile = argv.configFile || './config.json'
-
-  try {
-    const file = fs.readFileSync(configFile)
-
-    // Use flags with priority over config file
-    const config = JSON.parse(file)
-    argv = { ...config, ...argv }
-  } catch (err) {
-    // If config file was specified, but it doesn't exist, stop with error message
-    if (typeof argv.configFile !== 'undefined') {
-      if (!fs.existsSync(configFile)) {
-        console.log(red(bold('ERR')), 'Config file ' + configFile + ' doesn\'t exist.')
-        process.exit(1)
-      }
-    }
-
-    // If the file exists, but parsing failed, stop with error message
-    if (fs.existsSync(configFile)) {
-      console.log(red(bold('ERR')), 'config file ' + configFile + ' couldn\'t be parsed: ' + err)
-      process.exit(1)
-    }
-
-    // Legacy behavior - if config file does not exist, start with default
-    // values, but an info message to create a config file.
-    console.log(cyan(bold('TIP')), 'create a config.json: `$ solid init`')
-  }
-
-  return argv
-}
-
-/**
- *
- * @param root
- * @param [serverUri] If not set, hostname must be set
- * @param [hostname] If not set, serverUri must be set
- * @returns {*}
- */
-function loadAccounts ({ root, serverUri, hostname }) {
-  const files = fs.readdirSync(root)
-  hostname = hostname || new URL(serverUri).hostname
-  const isUserDirectory = new RegExp(`.${hostname}$`)
-  return files
-    .filter(file => isUserDirectory.test(file))
-}
-
-function loadUsernames ({ root, serverUri }) {
-  const hostname = new URL(serverUri).hostname
-  return loadAccounts({ root, hostname })
-    .map(userDirectory => userDirectory.substr(0, userDirectory.length - hostname.length - 1))
-}

package/bin/lib/cli.js

@@ -1,39 +0,0 @@
-const program = require('commander')
-const loadInit = require('./init')
-const loadStart = require('./start')
-const loadInvalidUsernames = require('./invalidUsernames')
-const loadMigrateLegacyResources = require('./migrateLegacyResources')
-const loadUpdateIndex = require('./updateIndex')
-const { spawnSync } = require('child_process')
-const path = require('path')
-
-module.exports = function startCli (server) {
-  program.version(getVersion())
-
-  loadInit(program)
-  loadStart(program, server)
-  loadInvalidUsernames(program)
-  loadMigrateLegacyResources(program)
-  loadUpdateIndex(program)
-
-  program.parse(process.argv)
-  if (program.args.length === 0) program.help()
-}
-
-function getVersion () {
-  try {
-    // Obtain version from git
-    const options = { cwd: __dirname, encoding: 'utf8' }
-    const { stdout } = spawnSync('git', ['describe', '--tags'], options)
-    const { stdout: gitStatusStdout } = spawnSync('git', ['status'], options)
-    const version = stdout.trim()
-    if (version === '' || gitStatusStdout.match('Not currently on any branch')) {
-      throw new Error('No git version here')
-    }
-    return version
-  } catch (e) {
-    // Obtain version from package.json
-    const { version } = require(path.join(__dirname, '../../package.json'))
-    return version
-  }
-}

package/bin/solid.js

@@ -1,3 +0,0 @@
-#!/usr/bin/env -S node --experimental-require-module
-const startCli = require('./lib/cli')
-startCli()