standard lint issues

Author: CI Fix

lib/handlers/error-pages.mjs

@@ -1,6 +1,5 @@
 import { server as debug } from '../debug.mjs'
 import fs from 'fs'
-import { fileURLToPath } from 'url'
 import * as util from '../utils.mjs'
 import Auth from '../api/authn/index.mjs'
 
@@ -57,13 +56,8 @@ function renderDataBrowser (req, res) {
   res.set('Content-Type', 'text/html')
   const ldp = req.app.locals.ldp
   const defaultDataBrowser = import.meta.resolve('mashlib/dist/databrowser.html')
-  let dataBrowserPath = ldp.dataBrowserPath === 'default' ? defaultDataBrowser : ldp.dataBrowserPath
+  const dataBrowserPath = ldp.dataBrowserPath === 'default' ? defaultDataBrowser : ldp.dataBrowserPath
   debug('   sending data browser file: ' + dataBrowserPath)
-  // `import.meta.resolve` returns a file:// URL string; convert it to a
-  // filesystem path for `fs.readFileSync` when necessary.
-  if (typeof dataBrowserPath === 'string' && dataBrowserPath.startsWith('file://')) {
-    dataBrowserPath = fileURLToPath(dataBrowserPath)
-  }
   const dataBrowserHtml = fs.readFileSync(dataBrowserPath, 'utf8')
   res.set('content-type', 'text/html')
   res.send(dataBrowserHtml)

lib/handlers/patch.mjs

@@ -1,7 +1,6 @@
 // Express handler for LDP PATCH requests
 
 import bodyParser from 'body-parser'
-import fs from 'fs'
 import { handlers as debug } from '../debug.mjs'
 import HTTPError from '../http-error.mjs'
 import $rdf from 'rdflib'
@@ -74,11 +73,11 @@ async function execPatch (req, res, next) {
   let baseURI
   let targetURI
   let ldp
-  let path
+  // let path
 
   try {
     ldp = req.app.locals.ldp
-    path = res.locals.path || req.path
+    // path = res.locals.path || req.path
     baseURI = ldp.resourceMapper.resolveUrl(req.hostname, req.path)
     targetURI = baseURI
   } catch (err) {
@@ -95,7 +94,7 @@ async function execPatch (req, res, next) {
           // File does not exist, create empty graph
           debug('PATCH -- target does not exist, creating empty graph')
           contentTypeFromResourceFileName = contentTypeForNew(req)
-          const emptyGraph = $rdf.graph()
+          // const emptyGraph = $rdf.graph()
           resolve({
             stream: null,
             isContainer: false,
@@ -214,4 +213,4 @@ async function parseGraph (stream, uri, contentType) {
     })
     stream.on('error', reject)
   })
-}
+}

lib/ldp-middleware.mjs

@@ -1,4 +1,3 @@
-import { createRequire } from 'module'
 import express from 'express'
 import { linksHandler, addPermissions } from './header.mjs'
 import allow from './handlers/allow.mjs'
@@ -36,4 +35,4 @@ export default function LdpMiddleware (corsSettings, prep) {
   }
 
   return router
-}
+}

lib/models/account-manager.mjs

@@ -1,4 +1,4 @@
-import url from 'url'
+import { URL } from 'url'
 import rdf from 'rdflib'
 import vocab from 'solid-namespace'
 import defaults from '../../config/defaults.mjs'
@@ -25,56 +25,57 @@ class AccountManager {
     this.pathCard = options.pathCard || 'profile/card'
     this.suffixURI = options.suffixURI || '#me'
     this.accountTemplatePath = options.accountTemplatePath || './default-templates/new-account/'
-  }
+  }
 
   static from (options) {
     return new AccountManager(options)
-  }
+  }
 
   accountExists (accountName) {
     let accountUri
     let cardPath
     try {
       accountUri = this.accountUriFor(accountName)
-      accountUri = url.parse(accountUri).hostname
-      cardPath = url.resolve('/', this.pathCard)
+      accountUri = new URL(accountUri).hostname
+      // `pathCard` is a path fragment like 'profile/card' -> ensure it starts with '/'
+      cardPath = this.pathCard && this.pathCard.startsWith('/') ? this.pathCard : '/' + this.pathCard
     } catch (err) {
       return Promise.reject(err)
     }
     return this.accountUriExists(accountUri, cardPath)
-  }
+  }
 
   async accountUriExists (accountUri, accountResource = '/') {
     try {
       return await this.store.exists(accountUri, accountResource)
     } catch (err) {
       return false
     }
-  }
+  }
 
   accountDirFor (accountName) {
-    const { hostname } = url.parse(this.accountUriFor(accountName))
+    const { hostname } = new URL(this.accountUriFor(accountName))
     return this.store.resourceMapper.resolveFilePath(hostname)
-  }
+  }
 
   accountUriFor (accountName) {
     const accountUri = this.multiuser
       ? this.host.accountUriFor(accountName)
       : this.host.serverUri
     return accountUri
-  }
+  }
 
   accountWebIdFor (accountName) {
     const accountUri = this.accountUriFor(accountName)
-    const webIdUri = url.parse(url.resolve(accountUri, this.pathCard))
+    const webIdUri = new URL(this.pathCard, accountUri)
     webIdUri.hash = this.suffixURI
-    return webIdUri.format()
-  }
+    return webIdUri.toString()
+  }
 
   rootAclFor (userAccount) {
     const accountUri = this.accountUriFor(userAccount.username)
-    return url.resolve(accountUri, this.store.suffixAcl)
-  }
+    return new URL(this.store.suffixAcl, accountUri).toString()
+  }
 
   addCertKeyToProfile (certificate, userAccount) {
     if (!certificate) {
@@ -83,7 +84,7 @@ class AccountManager {
     return this.getProfileGraphFor(userAccount)
       .then(profileGraph => this.addCertKeyToGraph(certificate, profileGraph))
       .then(profileGraph => this.saveProfileGraph(profileGraph, userAccount))
-  }
+  }
 
   getProfileGraphFor (userAccount, contentType = DEFAULT_PROFILE_CONTENT_TYPE) {
     const webId = userAccount.webId
@@ -98,7 +99,7 @@ class AccountManager {
         error.message = `Error retrieving profile graph ${uri}: ` + error.message
         throw error
       })
-  }
+  }
 
   saveProfileGraph (profileGraph, userAccount, contentType = DEFAULT_PROFILE_CONTENT_TYPE) {
     const webId = userAccount.webId
@@ -109,7 +110,7 @@ class AccountManager {
     }
     const uri = userAccount.profileUri
     return this.store.putGraph(profileGraph, uri, contentType)
-  }
+  }
 
   addCertKeyToGraph (certificate, graph) {
     const webId = rdf.namedNode(certificate.webId)
@@ -127,7 +128,7 @@ class AccountManager {
     graph.add(key, ns.cert('modulus'), modulus)
     graph.add(key, ns.cert('exponent'), exponent)
     return graph
-  }
+  }
 
   userAccountFrom (userData) {
     const userConfig = {
@@ -164,16 +165,16 @@ class AccountManager {
       }
     }
     return UserAccount.from(userConfig)
-  }
+  }
 
   usernameFromWebId (webId) {
     if (!this.multiuser) {
       return DEFAULT_ADMIN_USERNAME
     }
-    const profileUrl = url.parse(webId)
+    const profileUrl = new URL(webId)
     const hostname = profileUrl.hostname
     return hostname.split('.')[0]
-  }
+  }
 
   createAccountFor (userAccount) {
     const template = AccountTemplate.for(userAccount)
@@ -182,46 +183,46 @@ class AccountManager {
     debug(`Creating account folder for ${userAccount.webId} at ${accountDir}`)
     return AccountTemplate.copyTemplateDir(templatePath, accountDir)
       .then(() => template.processAccount(accountDir))
-  }
+  }
 
   generateResetToken (userAccount) {
     return this.tokenService.generate('reset-password', { webId: userAccount.webId })
-  }
+  }
 
   generateDeleteToken (userAccount) {
     return this.tokenService.generate('delete-account.mjs', {
       webId: userAccount.webId,
       email: userAccount.email
     })
-  }
+  }
 
   validateDeleteToken (token) {
     const tokenValue = this.tokenService.verify('delete-account.mjs', token)
     if (!tokenValue) {
       throw new Error('Invalid or expired delete account token')
     }
     return tokenValue
-  }
+  }
 
   validateResetToken (token) {
     const tokenValue = this.tokenService.verify('reset-password', token)
     if (!tokenValue) {
       throw new Error('Invalid or expired reset token')
     }
     return tokenValue
-  }
+  }
 
   passwordResetUrl (token, returnToUrl) {
-    let resetUrl = url.resolve(this.host.serverUri, `/account/password/change?token=${token}`)
+    let resetUrl = new URL(`/account/password/change?token=${token}`, this.host.serverUri).toString()
     if (returnToUrl) {
       resetUrl += `&returnToUrl=${returnToUrl}`
     }
     return resetUrl
-  }
+  }
 
   getAccountDeleteUrl (token) {
-    return url.resolve(this.host.serverUri, `/account/delete/confirm?token=${token}`)
-  }
+    return new URL(`/account/delete/confirm?token=${token}`, this.host.serverUri).toString()
+  }
 
   loadAccountRecoveryEmail (userAccount) {
     return Promise.resolve()
@@ -237,7 +238,7 @@ class AccountManager {
         }
         return recoveryMailto
       })
-  }
+  }
 
   verifyEmailDependencies (userAccount) {
     if (!this.emailService) {
@@ -246,7 +247,7 @@ class AccountManager {
     if (userAccount && !userAccount.email) {
       throw new Error('Account recovery email has not been provided')
     }
-  }
+  }
 
   sendDeleteAccountEmail (userAccount) {
     return Promise.resolve()
@@ -261,7 +262,7 @@ class AccountManager {
         }
         return this.emailService.sendWithTemplate('delete-account.mjs', emailData)
       })
-  }
+  }
 
   sendPasswordResetEmail (userAccount, returnToUrl) {
     return Promise.resolve()
@@ -276,7 +277,7 @@ class AccountManager {
         }
         return this.emailService.sendWithTemplate('reset-password', emailData)
       })
-  }
+  }
 
   sendWelcomeEmail (newUser) {
     const emailService = this.emailService

lib/models/oidc-manager.mjs

@@ -1,12 +1,13 @@
-import url from 'url'
+/* eslint-disable no-unused-expressions */
+import { URL } from 'url'
 import path from 'path'
 import debug from '../debug.mjs'
 import OidcManager from '@solid/oidc-auth-manager'
 
 export function fromServerConfig (argv) {
   const providerUri = argv.host.serverUri
-  const authCallbackUri = url.resolve(providerUri, '/api/oidc/rp')
-  const postLogoutUri = url.resolve(providerUri, '/goodbye')
+  const authCallbackUri = new URL('/api/oidc/rp', providerUri).toString()
+  const postLogoutUri = new URL('/goodbye', providerUri).toString()
   const dbPath = path.join(argv.dbPath, 'oidc')
   const options = {
     debug,

lib/models/solid-host.mjs

@@ -1,11 +1,11 @@
-import url from 'url'
+import { URL } from 'url'
 import defaults from '../../config/defaults.mjs'
 
 class SolidHost {
   constructor (options = {}) {
     this.port = options.port || defaults.port
     this.serverUri = options.serverUri || defaults.serverUri
-    this.parsedUri = url.parse(this.serverUri)
+    this.parsedUri = new URL(this.serverUri)
     this.host = this.parsedUri.host
     this.hostname = this.parsedUri.hostname
     this.live = options.live
@@ -41,8 +41,9 @@ class SolidHost {
   }
 
   get authEndpoint () {
-    const authUrl = url.resolve(this.serverUri, '/authorize')
-    return url.parse(authUrl)
+    const authUrl = new URL('/authorize', this.serverUri)
+    // Return the WHATWG URL object
+    return authUrl
   }
 
   get cookieDomain () {