@small-tech/auto-encrypt 2.3.0 → 3.1.0

package/lib/HttpServer.js

@@ -25,12 +25,12 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-const http          = require('http')
-const encodeUrl     = require('encodeurl')
-const enableDestroy = require('server-destroy')
-const log           = require('./util/log')
+import http from 'http'
+import encodeUrl from 'encodeurl'
+import enableDestroy from 'server-destroy'
+import log from './util/log.js'
 
-class HttpServer {
+export default class HttpServer {
   //
   // Singleton access (async).
   //
@@ -169,5 +169,3 @@ class HttpServer {
     })
   }
 }
-
-module.exports = HttpServer

package/lib/Identity.js

@@ -14,17 +14,17 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-const util          = require('util')
-const fs            = require('fs-extra')
-const jose          = require('jose')
-const Throws        = require('./util/Throws')
-const log           = require('./util/log')
+import util from 'util'
+import fs from 'fs'
+import jose from 'jose'
+import Throws from './util/Throws.js'
+import log from './util/log.js'
 
 const throws = new Throws({
   [Symbol.for('UnsupportedIdentityType')]: identityFilePath => `The identity file path passed (${identityFilePath}) is for an unsupported identity type.`
 })
 
-class Identity {
+export default class Identity {
 
   constructor (configuration = throws.ifMissing(), identityFilePathKey = throws.ifMissing()) {
     const identityFilePath = configuration[identityFilePathKey]
@@ -109,5 +109,3 @@ class Identity {
   //
   #identityFilePath = null
 }
-
-module.exports = Identity

package/lib/LetsEncryptServer.js

@@ -1,6 +1,6 @@
-const util = require('util')
+import util from 'util'
 
-class LetsEncryptServer {
+export default class LetsEncryptServer {
   /**
    * Enumeration.
    *
@@ -54,5 +54,3 @@ class LetsEncryptServer {
     'http://localhost:9829/directory'
   ]
 }
-
-module.exports = LetsEncryptServer

package/lib/Nonce.js

@@ -20,13 +20,13 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-const prepareRequest = require('bent')
-const log            = require('./util/log')
-const Throws         = require('./util/Throws')
+import prepareRequest from 'bent'
+import log from './util/log.js'
+import Throws from './util/Throws.js'
 
 const throws = new Throws()
 
-class Nonce {
+export default class Nonce {
   constructor (directory = throws.ifMissing()) {
     this.#directory = directory
   }
@@ -73,5 +73,3 @@ class Nonce {
   #directory = null
   #freshNonce = null
 }
-
-module.exports = Nonce

package/lib/Order.js

@@ -12,23 +12,23 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-const fs                      = require('fs-extra')
-const Authorisation           = require('./Authorisation')
-const HttpServer              = require('./HttpServer')
-const CertificateIdentity     = require('./identities/CertificateIdentity')
-const acmeCsr                 = require('./acmeCsr')
-const asyncForEach            = require('./util/async-foreach')
-const log                     = require('./util/log')
-const NewOrderRequest         = require('./acme-requests/NewOrderRequest')
-const FinaliseOrderRequest    = require('./acme-requests/FinaliseOrderRequest')
-const CheckOrderStatusRequest = require('./acme-requests/CheckOrderStatusRequest')
-const CertificateRequest      = require('./acme-requests/CertificateRequest')
-const Throws                  = require('./util/Throws')
-const waitFor                 = require('./util/waitFor')
+import fsPromises from 'fs/promises'
+import Authorisation from './Authorisation.js'
+import HttpServer from './HttpServer.js'
+import CertificateIdentity from './identities/CertificateIdentity.js'
+import acmeCsr from './acmeCsr.js'
+import asyncForEach from './util/async-foreach.js'
+import log from './util/log.js'
+import NewOrderRequest from './acme-requests/NewOrderRequest.js'
+import FinaliseOrderRequest from './acme-requests/FinaliseOrderRequest.js'
+import CheckOrderStatusRequest from './acme-requests/CheckOrderStatusRequest.js'
+import CertificateRequest from './acme-requests/CertificateRequest.js'
+import Throws from './util/Throws.js'
+import waitFor from './util/waitFor.js'
 
 const throws = new Throws()
 
-class Order {
+export default class Order {
   #data                = null
   #headers             = null
   #order               = null
@@ -193,7 +193,7 @@ class Order {
 
         // Save the certificate.
         try {
-          await fs.writeFile(this.configuration.certificatePath, this.certificate, 'utf-8')
+          await fsPromises.writeFile(this.configuration.certificatePath, this.certificate, 'utf-8')
         } catch (error) {
           throw new Error(error)
         }
@@ -214,5 +214,3 @@ class Order {
     }
   }
 }
-
-module.exports = Order

package/lib/acme-requests/AuthorisationRequest.js

@@ -11,12 +11,12 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-const AcmeRequest = require('../AcmeRequest')
-const Throws = require('../util/Throws')
+import AcmeRequest from '../AcmeRequest.js'
+import Throws from '../util/Throws.js'
 
 const throws = new Throws()
 
-class AuthorisationRequest extends AcmeRequest {
+export default class AuthorisationRequest extends AcmeRequest {
   async execute (authorisationUrl = throws.ifMissing()) {
     // This is a POST-as-GET request so it doesn’t have a payload.
     // See RFC 8555 § 6.3 (GET and POST-as-GET requests).
@@ -34,5 +34,3 @@ class AuthorisationRequest extends AcmeRequest {
     return response
   }
 }
-
-module.exports = AuthorisationRequest

package/lib/acme-requests/CertificateRequest.js

@@ -12,12 +12,12 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-const AcmeRequest = require('../AcmeRequest')
-const Throws      = require('../util/Throws')
+import AcmeRequest from '../AcmeRequest.js'
+import Throws from '../util/Throws.js'
 
 const throws = new Throws()
 
-class CertificateRequest extends AcmeRequest {
+export default class CertificateRequest extends AcmeRequest {
   async execute (certificateUrl = throws.ifMissing()) {
     // This is a POST-as-GET request so it doesn’t have a payload.
     // See RFC 8555 § 6.3 (GET and POST-as-GET requests).
@@ -37,5 +37,3 @@ class CertificateRequest extends AcmeRequest {
     return response
   }
 }
-
-module.exports = CertificateRequest

package/lib/acme-requests/CheckOrderStatusRequest.js

@@ -14,12 +14,12 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-const AcmeRequest = require('../AcmeRequest')
-const Throws      = require('../util/Throws')
+import AcmeRequest from '../AcmeRequest.js'
+import Throws from '../util/Throws.js'
 
 const throws = new Throws()
 
-class CheckOrderStatusRequest extends AcmeRequest {
+export default class CheckOrderStatusRequest extends AcmeRequest {
   async execute (orderUrl = throws.ifMissing()) {
 
     const payload = '' // POST-as-GET
@@ -35,5 +35,3 @@ class CheckOrderStatusRequest extends AcmeRequest {
     return response
   }
 }
-
-module.exports = CheckOrderStatusRequest

package/lib/acme-requests/FinaliseOrderRequest.js

@@ -11,12 +11,12 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-const AcmeRequest = require('../AcmeRequest')
-const Throws = require('../util/Throws')
+import AcmeRequest from '../AcmeRequest.js'
+import Throws from '../util/Throws.js'
 
 const throws = new Throws()
 
-class FinaliseOrderRequest extends AcmeRequest {
+export default class FinaliseOrderRequest extends AcmeRequest {
   async execute (finaliseUrl = throws.ifMissing(), csr = throws.ifMissing()) {
 
     const payload = { csr }
@@ -32,5 +32,3 @@ class FinaliseOrderRequest extends AcmeRequest {
     return response
   }
 }
-
-module.exports = FinaliseOrderRequest

package/lib/acme-requests/NewAccountRequest.js

@@ -12,9 +12,9 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-const AcmeRequest = require('../AcmeRequest')
+import AcmeRequest from '../AcmeRequest.js'
 
-class NewAccountRequest extends AcmeRequest {
+export default class NewAccountRequest extends AcmeRequest {
   async execute () {
     // Set the only required element.
     const payload = { termsOfServiceAgreed: true }
@@ -30,5 +30,3 @@ class NewAccountRequest extends AcmeRequest {
     return account
   }
 }
-
-module.exports = NewAccountRequest

package/lib/acme-requests/NewOrderRequest.js

@@ -12,11 +12,11 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-const AcmeRequest = require('../AcmeRequest')
-const Throws = require('../util/Throws')
+import AcmeRequest from '../AcmeRequest.js'
+import Throws from '../util/Throws.js'
 const throws = new Throws()
 
-class NewOrderRequest extends AcmeRequest {
+export default class NewOrderRequest extends AcmeRequest {
   async execute (configuration = throws.ifMissing()) {
     const identifiers = configuration.domains.map(domain => { return { type: 'dns', value: domain} })
     const payload = { identifiers }
@@ -25,5 +25,3 @@ class NewOrderRequest extends AcmeRequest {
     return response
   }
 }
-
-module.exports = NewOrderRequest

package/lib/acme-requests/ReadyForChallengeValidationRequest.js

@@ -13,12 +13,12 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-const AcmeRequest = require('../AcmeRequest')
-const Throws = require('../util/Throws')
+import AcmeRequest from '../AcmeRequest.js'
+import Throws from '../util/Throws.js'
 
 const throws = new Throws()
 
-class ReadyForChallengeValidationRequest extends AcmeRequest {
+export default class ReadyForChallengeValidationRequest extends AcmeRequest {
   async execute (challengeUrl = throws.ifMissing()) {
     const emptyPayload = {}
 
@@ -33,5 +33,3 @@ class ReadyForChallengeValidationRequest extends AcmeRequest {
     return response
   }
 }
-
-module.exports = ReadyForChallengeValidationRequest

package/lib/acmeCsr.js

@@ -12,7 +12,7 @@
 // License: AGPLv3 or later.
 //
 ////////////////////////////////////////////////////////////////////////////////
-const forge = require('node-forge')
+import forge from 'node-forge'
 const DNS = 2 // The ANS.1 type for DNS name.
 
 // Returns a valid ACME-formatted (RFC 8555) CSR.
@@ -24,7 +24,7 @@ const DNS = 2 // The ANS.1 type for DNS name.
  * @param {JWK.rsaKey} key
  * @returns {String} An ACME-formatted CSR in PEM format.
  */
-module.exports = function (domains, key) { return pemToAcmeCsr(csrAsPem(domains, key)) }
+export default function (domains, key) { return pemToAcmeCsr(csrAsPem(domains, key)) }
 
 /**
  * Create a CSR given a list of domains and a Jose JWK.rsaKey.

package/lib/identities/AccountIdentity.js

@@ -12,14 +12,12 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-const Identity = require('../Identity')
-const Throws = require('../util/Throws')
+import Identity from '../Identity.js'
+import Throws from '../util/Throws.js'
 const throws = new Throws()
 
-class AccountIdentity extends Identity {
+export default class AccountIdentity extends Identity {
   constructor (configuration = throws.ifMissing()) {
     super(configuration, 'accountIdentityPath')
   }
 }
-
-module.exports = AccountIdentity

package/lib/identities/CertificateIdentity.js

@@ -1,5 +1,5 @@
-const Identity = require('../Identity')
-const Throws = require('../util/Throws')
+import Identity from '../Identity.js'
+import Throws from '../util/Throws.js'
 const throws = new Throws()
 
 /**
@@ -13,7 +13,7 @@ const throws = new Throws()
  * @copyright Aral Balkan, Small Technology Foundation
  * @license AGPLv3 or later
  */
-class CertificateIdentity extends Identity {
+export default class CertificateIdentity extends Identity {
   /**
    * Creates an instance of CertificateIdentity.
    *
@@ -24,5 +24,3 @@ class CertificateIdentity extends Identity {
     super(configuration, 'certificateIdentityPath')
   }
 }
-
-module.exports = CertificateIdentity

package/lib/staging/monkeyPatchTls.js

@@ -7,16 +7,19 @@
  * @copyright Copyright © 2020 Aral Balkan, Small Technology Foundation.
  * @license AGPLv3 or later.
  */
-const fs   = require('fs')
-const tls  = require('tls')
-const path = require('path')
+import fs from 'fs'
+import tls from 'tls'
+import path from 'path'
+import { fileURLToPath } from 'url'
+
+const __dirname = fileURLToPath(new URL('.', import.meta.url))
 
 /**
  * Monkey patches the TLS module to accept the Let’s Encrypt staging certificate.
  *
  * @alias module:lib/MonkeyPatchTls
  */
-function monkeyPatchTLS () {
+export default function monkeyPatchTLS () {
   const originalCreateSecureContext = tls.createSecureContext
 
   let pem = fs
@@ -35,5 +38,3 @@ function monkeyPatchTLS () {
     return context
   }
 }
-
-module.exports = monkeyPatchTLS

package/lib/test-helpers/index.js

@@ -4,15 +4,15 @@
 //
 //////////////////////////////////////////////////////////////////////
 
-const fs                  = require('fs-extra')
-const os                  = require('os')
-const path                = require('path')
-const http                = require('http')
-const enableServerDestroy = require('server-destroy')
-const Configuration       = require('../Configuration')
-const LetsEncryptServer   = require('../LetsEncryptServer')
-const Throws              = require('../util/Throws')
-const log                 = require('../util/log')
+import fs from 'fs'
+import os from 'os'
+import path from 'path'
+import http from 'http'
+import enableServerDestroy from 'server-destroy'
+import Configuration from '../Configuration.js'
+import LetsEncryptServer from '../LetsEncryptServer.js'
+import Throws from '../util/Throws.js'
+import log from '../util/log.js'
 
 //
 // Server mocks.
@@ -22,7 +22,7 @@ const throws = new Throws({
   [Symbol.for('MockServerCouldNotBeStartedError')]: details => `Mock server could not be started (${error})`
 })
 
-class MockServer {
+export class MockServer {
   static #isBeingInstantiatedViaAsyncFactoryMethod = false
 
   static async getInstanceAsync (responseHandler = throws.ifMissing()) {
@@ -64,7 +64,7 @@ class MockServer {
   }
 }
 
-async function httpServerWithResponse (mockResponse) {
+export async function httpServerWithResponse (mockResponse) {
   return new Promise((resolve, reject) => {
     const server = http.createServer((request, response) => {
       response.statusCode = mockResponse.statusCode
@@ -76,18 +76,26 @@ async function httpServerWithResponse (mockResponse) {
   })
 }
 
+//
+// Pebble setup and teardown.
+//
+
+export class TestContext {
+
+}
+
 //
 // Timing.
 //
 
-function timeIt(func) {
+export function timeIt(func) {
   const startTime = new Date()
   const returnValue = func()
   const endTime = new Date()
   return { returnValue, duration: endTime - startTime }
 }
 
-async function timeItAsync(func) {
+export async function timeItAsync(func) {
   const startTime = new Date()
   const returnValue = await func()
   const endTime = new Date()
@@ -98,7 +106,7 @@ async function timeItAsync(func) {
 // Error validation.
 //
 
-function symbolOfErrorThrownBy(func) {
+export function symbolOfErrorThrownBy(func) {
   try {
     func()
     return false
@@ -108,7 +116,7 @@ function symbolOfErrorThrownBy(func) {
   }
 }
 
-async function symbolOfErrorThrownByAsync(func) {
+export async function symbolOfErrorThrownByAsync(func) {
   try {
     await func()
     return false
@@ -118,7 +126,7 @@ async function symbolOfErrorThrownByAsync(func) {
   }
 }
 
-function throwsErrorOfType (func, errorSymbol) {
+export function throwsErrorOfType (func, errorSymbol) {
   try {
     func()
   } catch (error) {
@@ -129,7 +137,7 @@ function throwsErrorOfType (func, errorSymbol) {
   return false
 }
 
-async function throwsErrorOfTypeAsync (asyncFunc, errorSymbol) {
+export async function throwsErrorOfTypeAsync (asyncFunc, errorSymbol) {
   try {
     await asyncFunc()
   } catch (error) {
@@ -140,18 +148,17 @@ async function throwsErrorOfTypeAsync (asyncFunc, errorSymbol) {
   return false
 }
 
-
-function dehydrate (string) {
+export function dehydrate (string) {
   return string.replace(/\s/g, '')
 }
 
-function createTestSettingsPath () {
-  testSettingsPath = path.join(os.homedir(), '.small-tech.org', 'auto-encrypt', 'test')
-  fs.removeSync(testSettingsPath)
+export function createTestSettingsPath () {
+  const testSettingsPath = path.join(os.homedir(), '.small-tech.org', 'auto-encrypt', 'test')
+  fs.rmSync(testSettingsPath, { recursive: true, force: true })
   return testSettingsPath
 }
 
-function initialiseStagingConfigurationWithOneDomainAtTestSettingsPath () {
+export function initialiseStagingConfigurationWithOneDomainAtTestSettingsPath () {
   Configuration.reset()
   Configuration.initialise({
     domains: ['dev.ar.al'],
@@ -160,21 +167,6 @@ function initialiseStagingConfigurationWithOneDomainAtTestSettingsPath () {
   })
 }
 
-function setupStagingConfigurationWithOneDomainAtTestSettingsPath () {
+export function setupStagingConfigurationWithOneDomainAtTestSettingsPath () {
   initialiseStagingConfigurationWithOneDomainAtTestSettingsPath()
 }
-
-module.exports = {
-  MockServer,
-  timeIt,
-  timeItAsync,
-  symbolOfErrorThrownByAsync,
-  symbolOfErrorThrownBy,
-  throwsErrorOfType,
-  throwsErrorOfTypeAsync,
-  dehydrate,
-  createTestSettingsPath,
-  initialiseStagingConfigurationWithOneDomainAtTestSettingsPath,
-  setupStagingConfigurationWithOneDomainAtTestSettingsPath,
-  httpServerWithResponse
-}

package/lib/util/Pluralise.js

@@ -1,4 +1,4 @@
-class Pluralise {
+export default class Pluralise {
 
   static requiresEs (word) {
     // Note: this is not meant to be comprehensive. It doesn’t take into consideration
@@ -17,5 +17,3 @@ class Pluralise {
     return array.length === 1 ? word : `${word}${this.requiresEs(word) ? 'es' : 's'}`
   }
 }
-
-module.exports = Pluralise

package/lib/util/Throws.js

@@ -11,7 +11,7 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-const fs = require('fs-extra')
+import fs from 'fs'
 
 class SymbolicError extends Error {
   symbol = null
@@ -21,7 +21,7 @@ class SymbolicError extends Error {
 // at the end of the error message, in parentheses.
 const hinted = (str, hint) => hint ? `${str} (${hint}).` : `${str}.`
 
-class Throws {
+export default class Throws {
   // Define common global errors. These are mixed into a local ERRORS object
   // if it exists on the object the mixin() method is called with a reference to.
   static ERRORS = {
@@ -75,7 +75,6 @@ class Throws {
   }
 
   ifMissing (parameterName) {
-
     // Attempt to automatically get the argument name even if parameterName was not
     // manually specified in the code.
     //
@@ -87,7 +86,7 @@ class Throws {
     const stack = new Error().stack;
     Error.prepareStackTrace = copy;
 
-    const fileName = stack[1].getFileName();
+    const fileName = stack[1].getFileName().replace('file://', '');
     const lineNumber = stack[1].getLineNumber() - 1;
     const columnNumber = stack[1].getColumnNumber() - 1;
     const line = fs.readFileSync(fileName, "utf8").split("\n")[lineNumber];
@@ -97,7 +96,6 @@ class Throws {
     if (groups !== null) {
       argumentName = groups[2]
     }
-
     this.error(Symbol.for('UndefinedOrNullError'), parameterName || argumentName || '<unknown>')
   }
 
@@ -117,5 +115,3 @@ class Throws {
     throw this.createError(symbol, ...args)
   }
 }
-
-module.exports = Throws

package/lib/util/async-foreach.js

@@ -20,10 +20,8 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-async function asyncForEach(array, callback) {
+export default async function asyncForEach(array, callback) {
   for (let index = 0; index < array.length; index++) {
     await callback(array[index], index, array);
   }
 }
-
-module.exports = asyncForEach

package/lib/util/log.js

@@ -1,9 +1,7 @@
 // Conditionally log to console.
-function log (...args) {
+export default function log (...args) {
   if (process.env.QUIET) {
     return
   }
   console.log(...args)
 }
-
-module.exports = log

package/lib/util/waitFor.js

@@ -1,5 +1,3 @@
-function waitFor(ms) {
+export default function waitFor(ms) {
   return new Promise(resolve => setTimeout(resolve, ms))
 }
-
-module.exports = waitFor