@jsenv/https-local 1.0.11 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/https-local",
-  "version": "1.0.11",
+  "version": "1.1.0",
   "description": "A programmatic way to generate locally trusted certificates",
   "license": "MIT",
   "author": {
@@ -48,10 +48,10 @@
     "playwright-install": "npx playwright install-deps && npx playwright install"
   },
   "dependencies": {
-    "@jsenv/eslint-import-resolver": "0.1.7",
-    "@jsenv/filesystem": "3.2.2",
-    "@jsenv/log": "1.6.0",
-    "@jsenv/logger": "4.0.1",
+    "@jsenv/filesystem": "4.0.2",
+    "@jsenv/log": "1.6.3",
+    "@jsenv/logger": "4.1.1",
+    "@jsenv/urls": "1.1.2",
     "command-exists": "1.2.9",
     "node-forge": "1.3.1",
     "sudo-prompt": "9.2.1",
@@ -59,16 +59,17 @@
   },
   "devDependencies": {
     "@jsenv/assert": "2.5.4",
-    "@jsenv/core": "27.0.0-alpha.61",
+    "@jsenv/core": "27.0.0-alpha.69",
     "@jsenv/eslint-config": "16.0.9",
+    "@jsenv/eslint-import-resolver": "0.1.11",
     "@jsenv/github-release-package": "1.4.0",
     "@jsenv/importmap-eslint-resolver": "5.2.5",
     "@jsenv/importmap-node-module": "5.1.3",
-    "@jsenv/package-publish": "1.7.4",
+    "@jsenv/package-publish": "1.7.5",
     "@jsenv/performance-impact": "2.2.11",
-    "eslint": "8.16.0",
+    "eslint": "8.17.0",
     "eslint-plugin-import": "2.26.0",
     "playwright": "1.22.2",
-    "prettier": "2.6.2"
+    "prettier": "2.7.0"
   }
 }

package/src/internal/authority_file_infos.js

@@ -1,5 +1,5 @@
 import { existsSync } from "node:fs"
-import { urlToFileSystemPath } from "@jsenv/filesystem"
+import { fileURLToPath } from "node:url"
 
 import { getCertificateAuthorityFileUrls } from "./certificate_authority_file_urls.js"
 
@@ -10,15 +10,13 @@ export const getAuthorityFileInfos = () => {
     rootCertificatePrivateKeyFileUrl,
   } = getCertificateAuthorityFileUrls()
 
-  const authorityJsonFilePath = urlToFileSystemPath(
-    certificateAuthorityJsonFileUrl,
-  )
+  const authorityJsonFilePath = fileURLToPath(certificateAuthorityJsonFileUrl)
   const authorityJsonFileDetected = existsSync(authorityJsonFilePath)
 
-  const rootCertificateFilePath = urlToFileSystemPath(rootCertificateFileUrl)
+  const rootCertificateFilePath = fileURLToPath(rootCertificateFileUrl)
   const rootCertificateFileDetected = existsSync(rootCertificateFilePath)
 
-  const rootCertificatePrivateKeyFilePath = urlToFileSystemPath(
+  const rootCertificatePrivateKeyFilePath = fileURLToPath(
     rootCertificatePrivateKeyFileUrl,
   )
   const rootCertificatePrivateKeyFileDetected = existsSync(

package/src/internal/certificate_authority_file_urls.js

@@ -1,8 +1,5 @@
-import {
-  assertAndNormalizeDirectoryUrl,
-  resolveUrl,
-  urlToFilename,
-} from "@jsenv/filesystem"
+import { urlToFilename } from "@jsenv/urls"
+import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem"
 
 export const getCertificateAuthorityFileUrls = () => {
   // we need a directory common to every instance of @jsenv/https-local
@@ -20,10 +17,10 @@ export const getCertificateAuthorityFileUrls = () => {
     applicationDirectoryUrl,
   )
 
-  const rootCertificatePrivateKeyFileUrl = resolveUrl(
+  const rootCertificatePrivateKeyFileUrl = new URL(
     "./https_local_root_certificate.key",
     applicationDirectoryUrl,
-  )
+  ).href
 
   return {
     certificateAuthorityJsonFileUrl,
@@ -37,18 +34,19 @@ export const getRootCertificateSymlinkUrls = ({
   rootPrivateKeyFileUrl,
   serverCertificateFileUrl,
 }) => {
-  const serverCertificateDirectory = resolveUrl("./", serverCertificateFileUrl)
+  const serverCertificateDirectory = new URL("./", serverCertificateFileUrl)
+    .href
 
   const rootCertificateFilename = urlToFilename(rootCertificateFileUrl)
-  const rootCertificateSymlinkUrl = resolveUrl(
+  const rootCertificateSymlinkUrl = new URL(
     rootCertificateFilename,
     serverCertificateDirectory,
-  )
+  ).href
   const rootPrivateKeyFilename = urlToFilename(rootPrivateKeyFileUrl)
-  const rootPrivateKeySymlinkUrl = resolveUrl(
+  const rootPrivateKeySymlinkUrl = new URL(
     rootPrivateKeyFilename,
     serverCertificateDirectory,
-  )
+  ).href
 
   return {
     rootCertificateSymlinkUrl,
@@ -61,37 +59,37 @@ const getJsenvApplicationDirectoryUrl = () => {
   const { platform } = process
 
   if (platform === "darwin") {
-    return resolveUrl(
+    return new URL(
       `./Library/Application Support/https_local/`,
       assertAndNormalizeDirectoryUrl(process.env.HOME),
-    )
+    ).href
   }
 
   if (platform === "linux") {
     if (process.env.XDG_CONFIG_HOME) {
-      return resolveUrl(
+      return new URL(
         `./https_local/`,
         assertAndNormalizeDirectoryUrl(process.env.XDG_CONFIG_HOME),
-      )
+      ).href
     }
-    return resolveUrl(
+    return new URL(
       `./.config/https_local/`,
       assertAndNormalizeDirectoryUrl(process.env.HOME),
-    )
+    ).href
   }
 
   if (platform === "win32") {
     if (process.env.LOCALAPPDATA) {
-      return resolveUrl(
+      return new URL(
         `./https_local/`,
         assertAndNormalizeDirectoryUrl(process.env.LOCALAPPDATA),
-      )
+      ).href
     }
 
-    return resolveUrl(
+    return new URL(
       `./Local Settings/Application Data/https_local/`,
       assertAndNormalizeDirectoryUrl(process.env.USERPROFILE),
-    )
+    ).href
   }
 
   throw new Error(`platform not supported`)

package/src/internal/linux/chrome_linux.js

@@ -1,6 +1,6 @@
 import { existsSync } from "node:fs"
 import { execSync } from "node:child_process"
-import { resolveUrl, assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem"
+import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem"
 
 import { UNICODE } from "@jsenv/log"
 import {
@@ -48,10 +48,10 @@ export const executeTrustQueryOnChrome = ({
       logger.debug(`${UNICODE.INFO} Chrome not detected`)
       return false
     },
-    browserNSSDBDirectoryUrl: resolveUrl(
+    browserNSSDBDirectoryUrl: new URL(
       ".pki/nssdb",
       assertAndNormalizeDirectoryUrl(process.env.HOME),
-    ),
+    ).href,
     getBrowserClosedPromise: async () => {
       if (!isChromeOpen()) {
         return

package/src/internal/linux/firefox_linux.js

@@ -1,6 +1,6 @@
 import { existsSync } from "node:fs"
 import { execSync } from "node:child_process"
-import { resolveUrl, assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem"
+import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem"
 import { UNICODE } from "@jsenv/log"
 
 import {
@@ -48,10 +48,10 @@ export const executeTrustQueryOnFirefox = ({
       logger.debug(`${UNICODE.INFO} Firefox not detected`)
       return false
     },
-    browserNSSDBDirectoryUrl: resolveUrl(
+    browserNSSDBDirectoryUrl: new URL(
       ".mozilla/firefox/",
       assertAndNormalizeDirectoryUrl(process.env.HOME),
-    ),
+    ).href,
     getBrowserClosedPromise: async () => {
       if (!isFirefoxOpen()) {
         return

package/src/internal/linux/linux_trust_store.js

@@ -3,8 +3,9 @@
  */
 
 import { existsSync } from "node:fs"
+import { fileURLToPath } from "node:url"
 import { createDetailedMessage } from "@jsenv/logger"
-import { readFile, urlToFileSystemPath } from "@jsenv/filesystem"
+import { readFile } from "@jsenv/filesystem"
 import { UNICODE } from "@jsenv/log"
 
 import { exec } from "@jsenv/https-local/src/internal/exec.js"
@@ -50,7 +51,7 @@ export const executeTrustQueryOnLinux = async ({
   logger.debug(
     `Searching certificate file at ${JSENV_AUTHORITY_ROOT_CERTIFICATE_PATH}...`,
   )
-  const certificateFilePath = urlToFileSystemPath(certificateFileUrl)
+  const certificateFilePath = fileURLToPath(certificateFileUrl)
   const certificateStatus = await getCertificateStatus({ certificate })
 
   if (certificateStatus === "missing" || certificateStatus === "outdated") {

package/src/internal/mac/firefox_mac.js

@@ -1,6 +1,6 @@
 import { existsSync } from "node:fs"
 import { execSync } from "node:child_process"
-import { resolveUrl, assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem"
+import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem"
 import { UNICODE, createTaskLog } from "@jsenv/log"
 
 import { executeTrustQueryOnBrowserNSSDB } from "../nssdb_browser.js"
@@ -47,10 +47,10 @@ export const executeTrustQueryOnFirefox = ({
       logger.debug(`${UNICODE.INFO} firefox not detected`)
       return false
     },
-    browserNSSDBDirectoryUrl: resolveUrl(
+    browserNSSDBDirectoryUrl: new URL(
       `./Library/Application Support/Firefox/Profiles/`,
       assertAndNormalizeDirectoryUrl(process.env.HOME),
-    ),
+    ).href,
     getBrowserClosedPromise: async () => {
       if (!isFirefoxOpen()) {
         return

package/src/internal/mac/mac_keychain.js

@@ -1,6 +1,6 @@
 // https://ss64.com/osx/security.html
 
-import { urlToFileSystemPath } from "@jsenv/filesystem"
+import { fileURLToPath } from "node:url"
 import { createDetailedMessage } from "@jsenv/logger"
 
 import { UNICODE } from "@jsenv/log"
@@ -62,7 +62,7 @@ export const executeTrustQueryOnMacKeychain = async ({
       }
     }
 
-    const certificateFilePath = urlToFileSystemPath(certificateFileUrl)
+    const certificateFilePath = fileURLToPath(certificateFileUrl)
     // https://ss64.com/osx/security-cert.html
     const addTrustedCertCommand = `sudo security add-trusted-cert -d -r trustRoot -k ${systemKeychainPath} "${certificateFilePath}"`
     logger.info(`Adding certificate to mac keychain...`)

package/src/internal/mac/nss_mac.js

@@ -1,8 +1,5 @@
-import {
-  assertAndNormalizeDirectoryUrl,
-  resolveUrl,
-  urlToFileSystemPath,
-} from "@jsenv/filesystem"
+import { fileURLToPath } from "node:url"
+import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem"
 import { UNICODE } from "@jsenv/log"
 
 import { memoize } from "@jsenv/https-local/src/internal/memoize.js"
@@ -31,8 +28,8 @@ export const getCertutilBinPath = memoize(async () => {
   const nssCommandDirectoryUrl = assertAndNormalizeDirectoryUrl(
     brewCommandOutput.trim(),
   )
-  const certutilBinUrl = resolveUrl(`./bin/certutil`, nssCommandDirectoryUrl)
-  const certutilBinPath = urlToFileSystemPath(certutilBinUrl)
+  const certutilBinUrl = new URL(`./bin/certutil`, nssCommandDirectoryUrl).href
+  const certutilBinPath = fileURLToPath(certutilBinUrl)
   return certutilBinPath
 })
 

package/src/internal/nssdb_browser.js

@@ -4,14 +4,10 @@
  */
 
 import { existsSync } from "node:fs"
+import { fileURLToPath } from "node:url"
 import { createDetailedMessage } from "@jsenv/logger"
-import {
-  assertAndNormalizeDirectoryUrl,
-  collectFiles,
-  resolveUrl,
-  urlToFilename,
-  urlToFileSystemPath,
-} from "@jsenv/filesystem"
+import { urlToFilename } from "@jsenv/urls"
+import { assertAndNormalizeDirectoryUrl, collectFiles } from "@jsenv/filesystem"
 import { UNICODE } from "@jsenv/log"
 
 import { exec } from "@jsenv/https-local/src/internal/exec.js"
@@ -131,7 +127,7 @@ export const executeTrustQueryOnBrowserNSSDB = async ({
     }
   }
 
-  const certificateFilePath = urlToFileSystemPath(certificateFileUrl)
+  const certificateFilePath = fileURLToPath(certificateFileUrl)
   const certutilBinPath = await getCertutilBinPath()
 
   const checkNSSDB = async ({ NSSDBFileUrl }) => {
@@ -288,7 +284,7 @@ const findNSSDBFiles = async ({ logger, NSSDBDirectoryUrl }) => {
   }
 
   logger.debug(`Searching nss database files in directory...`)
-  const NSSDBDirectoryPath = urlToFileSystemPath(NSSDBDirectoryUrl)
+  const NSSDBDirectoryPath = fileURLToPath(NSSDBDirectoryUrl)
   const NSSDBDirectoryExists = existsSync(NSSDBDirectoryPath)
   if (!NSSDBDirectoryExists) {
     logger.info(
@@ -300,13 +296,9 @@ const findNSSDBFiles = async ({ logger, NSSDBDirectoryUrl }) => {
   NSSDBDirectoryUrl = assertAndNormalizeDirectoryUrl(NSSDBDirectoryUrl)
   const NSSDBFiles = await collectFiles({
     directoryUrl: NSSDBDirectoryUrl,
-    structuredMetaMap: {
-      isLegacyNSSDB: {
-        "./**/cert8.db": true,
-      },
-      isModernNSSDB: {
-        "./**/cert9.db": true,
-      },
+    associations: {
+      isLegacyNSSDB: { "./**/cert8.db": true },
+      isModernNSSDB: { "./**/cert9.db": true },
     },
     predicate: ({ isLegacyNSSDB, isModernNSSDB }) =>
       isLegacyNSSDB || isModernNSSDB,
@@ -324,7 +316,7 @@ const findNSSDBFiles = async ({ logger, NSSDBDirectoryUrl }) => {
     `${UNICODE.OK} found ${fileCount} nss database file in ${NSSDBDirectoryUrl}`,
   )
   const files = NSSDBFiles.map((file) => {
-    return resolveUrl(file.relativeUrl, NSSDBDirectoryUrl)
+    return new URL(file.relativeUrl, NSSDBDirectoryUrl).href
   })
   NSSDirectoryCache[NSSDBDirectoryUrl] = files
   return files
@@ -332,8 +324,8 @@ const findNSSDBFiles = async ({ logger, NSSDBDirectoryUrl }) => {
 
 const getDirectoryArgFromNSSDBFileUrl = (NSSDBFileUrl) => {
   const nssDBFilename = urlToFilename(NSSDBFileUrl)
-  const nssDBDirectoryUrl = resolveUrl("./", NSSDBFileUrl)
-  const nssDBDirectoryPath = urlToFileSystemPath(nssDBDirectoryUrl)
+  const nssDBDirectoryUrl = new URL("./", NSSDBFileUrl).href
+  const nssDBDirectoryPath = fileURLToPath(nssDBDirectoryUrl)
   return nssDBFilename === "cert8.db"
     ? `"${nssDBDirectoryPath}"`
     : `sql:"${nssDBDirectoryPath}"`

package/src/internal/windows/windows_certutil.js

@@ -3,8 +3,8 @@
  * https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/certutil
  */
 
+import { fileURLToPath } from "node:url"
 import { createDetailedMessage } from "@jsenv/logger"
-import { urlToFileSystemPath } from "@jsenv/filesystem"
 import { UNICODE } from "@jsenv/log"
 
 import { exec } from "@jsenv/https-local/src/internal/exec.js"
@@ -49,7 +49,7 @@ export const executeTrustQueryOnWindows = async ({
   const certutilListCommand = `certutil -store -user root`
   logger.debug(`${UNICODE.COMMAND} ${certutilListCommand}`)
   const certutilListCommandOutput = await exec(certutilListCommand)
-  const certificateFilePath = urlToFileSystemPath(certificateFileUrl)
+  const certificateFilePath = fileURLToPath(certificateFileUrl)
 
   // it's not super accurate and do not take into account if the cert is different
   // but it's the best I could do with certutil command on windows