ESM Migration: Convert main lib files and lib/api to ESM

- Create ESM versions (.mjs) for 7 main lib files:
  - capability-discovery.mjs
  - ldp-container.mjs
  - ldp.mjs (large 632-line file)
  - payment-pointer-discovery.mjs
  - rdf-notification-template.mjs
  - resource-mapper.mjs (227 lines)
  - server-config.mjs
- Convert lib/api/ directory to ESM:
  - index.mjs
  - accounts/user-accounts.mjs
  - authn/index.mjs
  - authn/force-user.mjs
- All files maintain dual CommonJS/ESM compatibility
- Proper import/export conversions with createRequire for CommonJS deps
- No errors detected in new ESM modules
- Total: 18 .mjs files now available in lib/ directory

Author: CI Fix

lib/api/accounts/user-accounts.mjs

@@ -0,0 +1,88 @@
+import express from 'express'
+import { urlencoded } from 'body-parser'
+const bodyParser = urlencoded({ extended: false })
+import debug from '../../debug.mjs'
+const debugAccounts = debug.accounts
+
+import restrictToTopDomain from '../../handlers/restrict-to-top-domain.mjs'
+
+import CreateAccountRequest from '../../requests/create-account-request.mjs'
+import AddCertificateRequest from '../../requests/add-cert-request.mjs'
+import DeleteAccountRequest from '../../requests/delete-account-request.mjs'
+import DeleteAccountConfirmRequest from '../../requests/delete-account-confirm-request.mjs'
+
+/**
+ * Returns an Express middleware handler for checking if a particular account
+ * exists (used by Signup apps).
+ *
+ * @param accountManager {AccountManager}
+ *
+ * @return {Function}
+ */
+export function checkAccountExists (accountManager) {
+  return (req, res, next) => {
+    const accountUri = req.hostname
+
+    accountManager.accountUriExists(accountUri)
+      .then(found => {
+        if (!found) {
+          debugAccounts(`Account ${accountUri} is available (for ${req.originalUrl})`)
+          return res.sendStatus(404)
+        }
+        debugAccounts(`Account ${accountUri} is not available (for ${req.originalUrl})`)
+        next()
+      })
+      .catch(next)
+  }
+}
+
+/**
+ * Returns an Express middleware handler for adding a new certificate to an
+ * existing account (POST to /api/accounts/cert).
+ *
+ * @param accountManager
+ *
+ * @return {Function}
+ */
+export function newCertificate (accountManager) {
+  return (req, res, next) => {
+    return AddCertificateRequest.handle(req, res, accountManager)
+      .catch(err => {
+        err.status = err.status || 400
+        next(err)
+      })
+  }
+}
+
+/**
+ * Returns an Express router for providing user account related middleware
+ * handlers.
+ *
+ * @param accountManager {AccountManager}
+ *
+ * @return {Router}
+ */
+export function middleware (accountManager) {
+  const router = express.Router('/')
+
+  router.get('/', checkAccountExists(accountManager))
+
+  router.post('/api/accounts/new', restrictToTopDomain, bodyParser, CreateAccountRequest.post)
+  router.get(['/register', '/api/accounts/new'], restrictToTopDomain, CreateAccountRequest.get)
+
+  router.post('/api/accounts/cert', restrictToTopDomain, bodyParser, newCertificate(accountManager))
+
+  router.get('/account/delete', restrictToTopDomain, DeleteAccountRequest.get)
+  router.post('/account/delete', restrictToTopDomain, bodyParser, DeleteAccountRequest.post)
+
+  router.get('/account/delete/confirm', restrictToTopDomain, DeleteAccountConfirmRequest.get)
+  router.post('/account/delete/confirm', restrictToTopDomain, bodyParser, DeleteAccountConfirmRequest.post)
+
+  return router
+}
+
+export default {
+  middleware,
+  checkAccountExists,
+  newCertificate
+}

lib/api/authn/force-user.mjs

@@ -0,0 +1,22 @@
+import debug from '../../debug.mjs'
+const debugAuth = debug.authentication
+
+/**
+ * Enforces the `--force-user` server flag, hardcoding a webid for all requests,
+ * for testing purposes.
+ */
+export function initialize (app, argv) {
+  const forceUserId = argv.forceUser
+  app.use('/', (req, res, next) => {
+    debugAuth(`Identified user (override): ${forceUserId}`)
+    req.session.userId = forceUserId
+    if (argv.auth === 'tls') {
+      res.set('User', forceUserId)
+    }
+    next()
+  })
+}
+
+export default {
+  initialize
+}

lib/api/authn/index.mjs

@@ -0,0 +1,9 @@
+export { default as oidc } from './webid-oidc.mjs'
+export { default as tls } from './webid-tls.mjs'
+export { default as forceUser } from './force-user.mjs'
+
+export default {
+  oidc: (await import('./webid-oidc.mjs')).default,
+  tls: (await import('./webid-tls.mjs')).default,
+  forceUser: (await import('./force-user.mjs')).default
+}

lib/api/index.mjs

@@ -0,0 +1,2 @@
+export { default as authn } from './authn/index.mjs'
+export { default as accounts } from './accounts/user-accounts.mjs'

lib/capability-discovery.mjs

@@ -0,0 +1,51 @@
+/**
+ * @module capability-discovery
+ */
+import express from 'express'
+import { URL } from 'url'
+
+/**
+ * Returns a set of routes to deal with server capability discovery
+ * @method capabilityDiscovery
+ * @return {Router} Express router
+ */
+export default function capabilityDiscovery () {
+  const router = express.Router('/')
+
+  // Advertise the server capability discover endpoint
+  router.get('/.well-known/solid', serviceCapabilityDocument())
+  return router
+}
+
+/**
+ * Serves the service capability document (containing server root URL, including
+ * any base path the user specified in config, server API endpoints, etc).
+ * @method serviceCapabilityDocument
+ * @param req
+ * @param res
+ * @param next
+ */
+function serviceCapabilityDocument () {
+  return (req, res) => {
+    const ldp = req.app.locals.ldp
+    res.json({
+      // Add the server root url
+      root: ldp.resourceMapper.resolveUrl(req.hostname, req.path),
+      // Add the 'apps' urls section
+      apps: req.app.locals.appUrls,
+      api: {
+        accounts: {
+          // 'changePassword': '/api/account/changePassword',
+          // 'delete': '/api/accounts/delete',
+
+          // Create new user (see IdentityProvider.post() in identity-provider.js)
+          new: new URL('/api/accounts/new', ldp.serverUri),
+          recover: new URL('/api/accounts/recover', ldp.serverUri),
+          signin: ldp.resourceMapper.resolveUrl(req.hostname, '/login'),
+          signout: ldp.resourceMapper.resolveUrl(req.hostname, '/logout'),
+          validateToken: new URL('/api/accounts/validateToken', ldp.serverUri)
+        }
+      }
+    })
+  }
+}

lib/ldp-container.mjs

@@ -0,0 +1,169 @@
+import { createRequire } from 'module'
+const require = createRequire(import.meta.url)
+
+const $rdf = require('rdflib')
+import debug from './debug.mjs'
+import error from './http-error.mjs'
+import fs from 'fs'
+const ns = require('solid-namespace')($rdf)
+const mime = require('mime-types')
+import path from 'path'
+
+export { addContainerStats, addFile, addStats, readdir }
+
+async function addContainerStats (ldp, reqUri, filename, resourceGraph) {
+  const containerStats = await ldp.stat(filename)
+  addStats(resourceGraph, reqUri, containerStats, filename)
+  const storage = new URL(reqUri)
+  if (reqUri === storage.origin + '/') {
+    resourceGraph.add(
+      resourceGraph.sym(reqUri),
+      ns.rdf('type'),
+      ns.space('Storage')
+    )
+  }
+  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()
+  }
+}