@jsenv/server 7.1.0 → 8.0.0

package/README.md

@@ -1,6 +1,6 @@
-# server · [![npm package](https://img.shields.io/npm/v/@jsenv/server.svg?logo=npm&label=package)](https://www.npmjs.com/package/@jsenv/server) [![github workflow](https://github.com/jsenv/server/workflows/main/badge.svg)](https://github.com/jsenv/server/actions?workflow=main) [![codecov coverage](https://codecov.io/gh/jsenv/server/branch/main/graph/badge.svg)](https://codecov.io/gh/jsenv/server)
+# server [![npm package](https://img.shields.io/npm/v/@jsenv/server.svg?logo=npm&label=package)](https://www.npmjs.com/package/@jsenv/server) [![github workflow](https://github.com/jsenv/server/workflows/main/badge.svg)](https://github.com/jsenv/server/actions?workflow=main) [![codecov coverage](https://codecov.io/gh/jsenv/server/branch/main/graph/badge.svg)](https://codecov.io/gh/jsenv/server)
 
-`@jsenv/server` api helps to write flexible server code with a declarative API.
+`@jsenv/server` helps to write flexible server code with a declarative API.
 
 ```js
 import { startServer } from "@jsenv/server"
@@ -23,7 +23,7 @@ await startServer({
 
 # Example
 
-_Code starting a server and using [node-fetch](https://github.com/node-fetch/node-fetch) to send to request on that server:_
+_Code starting a server and using [node-fetch](https://github.com/node-fetch/node-fetch) to send a request on that server:_
 
 ```js
 import fetch from "node-fetch"
@@ -46,28 +46,39 @@ const responseBodyAsText = await response.text()
 console.log(responseBodyAsText) // "Hello world"
 ```
 
-_Code starting a server serving files from a directory:_
+_Code starting a server with 2 request handlers:_
 
 ```js
-import { startServer, serveFile } from "@jsenv/server"
-
-const buildDirectoryUrl = new URL("./dist/", import.meta.url)
-const LONG_TERM_CACHE_VALIDITY_IN_SECONDS = 60 * 60 * 24 * 30 // 30 days
+/*
+ * starts a server which:
+ * - when requested at "/"
+ *   -> respond with 200
+ * - otherwise
+ *   -> respond with 404
+ */
+import { startServer, composeServices } from "@jsenv/server"
+
+const indexService = (request) => {
+  if (request.ressource === "/") {
+    return { status: 200 }
+  }
+  return null // means "I don't handle that request"
+}
+
+const notFoundService = (request) => {
+  return { status: 404 }
+}
 
-await startServer({
-  requestToResponse: async (request) => {
-    const longTermCacheDisabled = request.ressource === "/index.html"
-    const response = await serveFile(request, {
-      rootDirectoryUrl: buildDirectoryUrl,
-      cacheControl: longTermCacheDisabled
-        ? `private,max-age=0,must-revalidate`
-        : `private,max-age=${LONG_TERM_CACHE_VALIDITY_IN_SECONDS},immutable`,
-      etagEnabled: true,
-      compressionEnabled: true,
-    })
-    return response
-  },
+const server = await startServer({
+  requestToResponse: composeServices(indexService, notFoundService),
 })
+
+const fetch = await import("node-fetch")
+const responseForOrigin = await fetch(server.origin)
+responseForOrigin.status // 200
+
+const responseForFoo = await fetch(`${server.origin}/foo`)
+responseForFoo.status // 404
 ```
 
 _Code starting a server in https:_
@@ -78,8 +89,8 @@ import { startServer } from "@jsenv/server"
 
 await startServer({
   protocol: "https",
-  serverCertificate: String(readFileSync(new URL("./server.crt", import.meta.url)),
-  serverCertificatePrivateKey: String(readFileSync(new URL("./server.key", import.meta.url)),
+  serverCertificate: readFileSyncAsString("./server.crt"),
+  serverCertificatePrivateKey: readFileSyncAsString("./server.key"),
   allowHttpRequestOnHttps: true,
   requestToResponse: (request) => {
     const clientUsesHttp = request.origin.startsWith("http:")
@@ -93,6 +104,35 @@ await startServer({
     }
   },
 })
+
+function readFileSyncAsString(relativeUrl) {
+  const fileUrl = new URL(relativeUrl, import.meta.url)
+  return String(readFileSync(fileUrl))
+}
+```
+
+_Code starting a server serving files from a directory:_
+
+```js
+import { startServer, serveFile } from "@jsenv/server"
+
+const distDirectoryUrl = new URL("./dist/", import.meta.url)
+const LONG_TERM_CACHE_VALIDITY_IN_SECONDS = 60 * 60 * 24 * 30 // 30 days
+
+await startServer({
+  requestToResponse: async (request) => {
+    const longTermCacheDisabled = request.ressource === "/index.html"
+    const response = await serveFile(request, {
+      rootDirectoryUrl: distDirectoryUrl,
+      cacheControl: longTermCacheDisabled
+        ? `private,max-age=0,must-revalidate`
+        : `private,max-age=${LONG_TERM_CACHE_VALIDITY_IN_SECONDS},immutable`,
+      etagEnabled: true,
+      compressionEnabled: true,
+    })
+    return response
+  },
+})
 ```
 
 # Documentation

package/main.js

@@ -3,27 +3,16 @@
  * Its responsability is to export what is documented
  * Ideally this file should be kept simple to help discovering codebase progressively.
  */
-/* eslint-disable import/max-dependencies */
 
-export { composeResponse } from "./src/composeResponse.js"
-export { convertFileSystemErrorToResponseProperties } from "./src/convertFileSystemErrorToResponseProperties.js"
-export { createSSERoom } from "./src/createSSERoom.js"
-export { fetchUrl } from "./src/fetchUrl.js"
-export { findFreePort } from "./src/findFreePort.js"
-export { headersToObject } from "./src/headersToObject.js"
-export { composeServices, composeServicesWithTiming } from "./src/service-composition.js"
-export { jsenvAccessControlAllowedHeaders } from "./src/jsenvAccessControlAllowedHeaders.js"
-export { jsenvAccessControlAllowedMethods } from "./src/jsenvAccessControlAllowedMethods.js"
+export { startServer } from "./src/startServer.js"
+export {
+  composeServices,
+  composeServicesWithTiming,
+  nextService,
+} from "./src/service_composition/service_composition.js"
 export { jsenvServerInternalErrorToResponse } from "./src/jsenvServerInternalErrorToResponse.js"
-export { negotiateContentEncoding } from "./src/negotiateContentEncoding.js"
-export { negotiateContentLanguage } from "./src/negotiateContentLanguage.js"
-export { negotiateContentType } from "./src/negotiateContentType.js"
-export { urlToContentType } from "./src/urlToContentType.js"
-export { urlToSearchParamValue } from "./src/urlToSearchParamValue.js"
 export { readRequestBody } from "./src/readRequestBody.js"
 export { serveFile } from "./src/serveFile.js"
-export { timeFunction, timeStart } from "./src/serverTiming.js"
-export { startServer } from "./src/startServer.js"
 export {
   STOP_REASON_INTERNAL_ERROR,
   STOP_REASON_PROCESS_SIGHUP,
@@ -33,3 +22,29 @@ export {
   STOP_REASON_PROCESS_EXIT,
   STOP_REASON_NOT_SPECIFIED,
 } from "./src/stopReasons.js"
+
+// CORS
+export {
+  pluginCORS,
+  jsenvAccessControlAllowedHeaders,
+  jsenvAccessControlAllowedMethods,
+} from "./src/cors/plugin_cors.js"
+
+// server timings
+export { pluginServerTiming } from "./src/server_timing/plugin_server_timing.js"
+export { timeFunction, timeStart } from "./src/server_timing/timing_measure.js"
+
+// SSE
+export { createSSERoom } from "./src/sse/createSSERoom.js"
+
+// content-negotiation
+export { negotiateContentType } from "./src/content_negotiation/negotiateContentType.js"
+export { negotiateContentEncoding } from "./src/content_negotiation/negotiateContentEncoding.js"
+export { negotiateContentLanguage } from "./src/content_negotiation/negotiateContentLanguage.js"
+export { pluginContentNegotiationCheck } from "./src/content_negotiation/plugin_content_negotiation_check.js"
+
+// others
+export { pluginRequestWaitingCheck } from "./src/plugin_request_waiting_check.js"
+export { findFreePort } from "./src/findFreePort.js"
+export { fetchUrl } from "./src/fetchUrl.js"
+export { urlToContentType } from "./src/urlToContentType.js"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/server",
-  "version": "7.1.0",
+  "version": "8.0.0",
   "description": "Write your Node.js server using pure functions",
   "license": "MIT",
   "author": {
@@ -33,41 +33,46 @@
   "scripts": {
     "eslint-check": "node ./node_modules/eslint/bin/eslint.js . --ext=.js,.mjs",
     "generate-importmap": "node ./script/importmap/generate_importmap.mjs",
-    "measure-performances": "node ./script/performance/generate_performance_report.mjs --local",
-    "test": "node ./script/test/test.mjs",
+    "measure-performances": "node --expose-gc ./script/performance/generate_performance_report.mjs --log",
+    "test": "node --unhandled-rejections=strict ./script/test/test.mjs",
     "test-with-coverage": "npm run test -- --coverage",
+    "generate-html-snapshots": "node ./test/internal_error/generate_html_snapshot_files.mjs",
     "prettier-format": "node ./script/prettier/prettier_format.mjs",
     "prettier-format-stage": "npm run prettier-format -- --staged",
     "prettier-check": "npm run prettier-format -- --dry-run",
-    "install-certificate-authority": "node ./script/certificate/install-certificate-authority.mjs",
+    "certificate-authority-install": "node ./script/certificate/certificate_authority_install.mjs",
+    "playwright-install": "npx playwright install-deps && npx playwright install",
     "prepublishOnly": "node ./script/publish/remove_postinstall.mjs",
     "postpublish": "node ./script/publish/restore_postinstall.mjs"
   },
   "dependencies": {
     "@jsenv/cancellation": "3.0.0",
-    "@jsenv/filesystem": "2.1.1",
+    "@jsenv/filesystem": "2.3.1",
     "@jsenv/logger": "4.0.1",
     "@jsenv/node-signals": "2.0.1",
     "abort-controller": "3.0.0",
     "node-fetch": "3.0.0"
   },
   "devDependencies": {
-    "@babel/core": "7.15.5",
-    "@babel/eslint-parser": "7.15.4",
-    "@jsenv/assert": "2.3.1",
+    "@babel/core": "7.15.8",
+    "@babel/eslint-parser": "7.15.8",
+    "@jsenv/assert": "2.3.2",
     "@jsenv/codecov-upload": "3.5.0",
-    "@jsenv/core": "19.6.2",
-    "@jsenv/eslint-config": "16.0.1",
+    "@jsenv/core": "23.1.3",
+    "@jsenv/eslint-config": "16.0.8",
     "@jsenv/github-release-package": "1.2.3",
     "@jsenv/https-local": "1.0.2",
-    "@jsenv/importmap-eslint-resolver": "5.1.0",
-    "@jsenv/importmap-node-module": "2.2.0",
+    "@jsenv/importmap-eslint-resolver": "5.1.2",
+    "@jsenv/importmap-node-module": "2.4.1",
     "@jsenv/package-publish": "1.6.2",
-    "@jsenv/performance-impact": "1.7.0",
+    "@jsenv/performance-impact": "2.2.0",
     "@jsenv/prettier-check-project": "5.6.1",
     "eslint": "7.32.0",
-    "eslint-plugin-import": "2.24.2",
+    "eslint-plugin-import": "2.25.2",
     "eventsource": "1.1.0",
-    "prettier": "2.3.2"
+    "fastify": "3.22.1",
+    "fastify-static": "4.4.2",
+    "playwright": "1.16.1",
+    "prettier": "2.4.1"
   }
 }

package/src/{internal → content_negotiation}/applyContentNegotiation.js

@@ -1,4 +1,8 @@
-export const applyContentNegotiation = ({ availables, accepteds, getAcceptanceScore }) => {
+export const applyContentNegotiation = ({
+  availables,
+  accepteds,
+  getAcceptanceScore,
+}) => {
   let highestScore = -1
   let availableWithHighestScore = null
 

package/src/{internal → content_negotiation}/checkContentNegotiation.js

@@ -1,6 +1,6 @@
-import { negotiateContentType } from "../negotiateContentType.js"
-import { negotiateContentLanguage } from "../negotiateContentLanguage.js"
-import { negotiateContentEncoding } from "../negotiateContentEncoding.js"
+import { negotiateContentType } from "./negotiateContentType.js"
+import { negotiateContentLanguage } from "./negotiateContentLanguage.js"
+import { negotiateContentEncoding } from "./negotiateContentEncoding.js"
 
 export const checkContentNegotiation = (request, response, { warn }) => {
   const requestAcceptHeader = request.headers.accept

package/src/{negotiateContentEncoding.js → content_negotiation/negotiateContentEncoding.js}

@@ -1,5 +1,5 @@
-import { applyContentNegotiation } from "./internal/applyContentNegotiation.js"
-import { parseMultipleHeader } from "./internal/multiple-header.js"
+import { parseMultipleHeader } from "../internal/multiple-header.js"
+import { applyContentNegotiation } from "./applyContentNegotiation.js"
 
 export const negotiateContentEncoding = (request, availableEncodings) => {
   const { headers = {} } = request
@@ -8,7 +8,9 @@ export const negotiateContentEncoding = (request, availableEncodings) => {
     return null
   }
 
-  const encodingsAccepted = parseAcceptEncodingHeader(requestAcceptEncodingHeader)
+  const encodingsAccepted = parseAcceptEncodingHeader(
+    requestAcceptEncodingHeader,
+  )
   return applyContentNegotiation({
     accepteds: encodingsAccepted,
     availables: availableEncodings,

package/src/{negotiateContentLanguage.js → content_negotiation/negotiateContentLanguage.js}

@@ -1,5 +1,5 @@
-import { applyContentNegotiation } from "./internal/applyContentNegotiation.js"
-import { parseMultipleHeader } from "./internal/multiple-header.js"
+import { parseMultipleHeader } from "../internal/multiple-header.js"
+import { applyContentNegotiation } from "./applyContentNegotiation.js"
 
 export const negotiateContentLanguage = (request, availableLanguages) => {
   const { headers = {} } = request
@@ -8,7 +8,9 @@ export const negotiateContentLanguage = (request, availableLanguages) => {
     return null
   }
 
-  const languagesAccepted = parseAcceptLanguageHeader(requestAcceptLanguageHeader)
+  const languagesAccepted = parseAcceptLanguageHeader(
+    requestAcceptLanguageHeader,
+  )
   return applyContentNegotiation({
     accepteds: languagesAccepted,
     availables: availableLanguages,
@@ -41,10 +43,12 @@ const parseAcceptLanguageHeader = (acceptLanguageHeaderString) => {
 
 const getLanguageAcceptanceScore = ({ value, quality }, availableLanguage) => {
   const [acceptedPrimary, acceptedVariant] = decomposeLanguage(value)
-  const [availablePrimary, availableVariant] = decomposeLanguage(availableLanguage)
+  const [availablePrimary, availableVariant] =
+    decomposeLanguage(availableLanguage)
 
   const primaryAccepted =
-    acceptedPrimary === "*" || acceptedPrimary.toLowerCase() === availablePrimary.toLowerCase()
+    acceptedPrimary === "*" ||
+    acceptedPrimary.toLowerCase() === availablePrimary.toLowerCase()
   const variantAccepted =
     acceptedVariant === "*" || compareVariant(acceptedVariant, availableVariant)
 

package/src/{negotiateContentType.js → content_negotiation/negotiateContentType.js}

@@ -1,5 +1,5 @@
-import { applyContentNegotiation } from "./internal/applyContentNegotiation.js"
-import { parseMultipleHeader } from "./internal/multiple-header.js"
+import { parseMultipleHeader } from "../internal/multiple-header.js"
+import { applyContentNegotiation } from "./applyContentNegotiation.js"
 
 export const negotiateContentType = (request, availableContentTypes) => {
   const { headers = {} } = request
@@ -39,12 +39,17 @@ const parseAcceptHeader = (acceptHeader) => {
   return accepts
 }
 
-const getContentTypeAcceptanceScore = ({ value, quality }, availableContentType) => {
+const getContentTypeAcceptanceScore = (
+  { value, quality },
+  availableContentType,
+) => {
   const [acceptedType, acceptedSubtype] = decomposeContentType(value)
-  const [availableType, availableSubtype] = decomposeContentType(availableContentType)
+  const [availableType, availableSubtype] =
+    decomposeContentType(availableContentType)
 
   const typeAccepted = acceptedType === "*" || acceptedType === availableType
-  const subtypeAccepted = acceptedSubtype === "*" || acceptedSubtype === availableSubtype
+  const subtypeAccepted =
+    acceptedSubtype === "*" || acceptedSubtype === availableSubtype
 
   if (typeAccepted && subtypeAccepted) {
     return quality

package/src/content_negotiation/plugin_content_negotiation_check.js

@@ -0,0 +1,15 @@
+import { checkContentNegotiation } from "./checkContentNegotiation.js"
+
+export const pluginContentNegotiationCheck = () => {
+  return {
+    content_negotiation_check: {
+      onRequest: (request, { warn }) => {
+        return {
+          onResponse: (response) => {
+            checkContentNegotiation(request, response, { warn })
+          },
+        }
+      },
+    },
+  }
+}

package/src/cors/plugin_cors.js

@@ -0,0 +1,156 @@
+import { urlToOrigin } from "@jsenv/filesystem"
+
+export const jsenvAccessControlAllowedHeaders = ["x-requested-with"]
+
+export const jsenvAccessControlAllowedMethods = [
+  "GET",
+  "POST",
+  "PUT",
+  "DELETE",
+  "OPTIONS",
+]
+
+export const pluginCORS = ({
+  accessControlAllowedOrigins = [],
+  accessControlAllowedMethods = jsenvAccessControlAllowedMethods,
+  accessControlAllowedHeaders = jsenvAccessControlAllowedHeaders,
+  accessControlAllowRequestOrigin = false,
+  accessControlAllowRequestMethod = false,
+  accessControlAllowRequestHeaders = false,
+  accessControlAllowCredentials = false,
+  // by default OPTIONS request can be cache for a long time, it's not going to change soon ?
+  // we could put a lot here, see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Max-Age
+  accessControlMaxAge = 600,
+  timingAllowOrigin,
+} = {}) => {
+  // TODO: we should check access control params to throw or warn if we find strange values
+
+  const corsEnabled =
+    accessControlAllowRequestOrigin || accessControlAllowedOrigins.length
+
+  if (!corsEnabled) {
+    return {
+      cors: {},
+    }
+  }
+
+  return {
+    cors: {
+      onServerParams: ({ plugins }) => {
+        if (timingAllowOrigin === undefined && plugins.server_timings) {
+          timingAllowOrigin = true
+        }
+      },
+
+      onRequest: (request, { shortcircuitResponse }) => {
+        if (request.method === "OPTIONS") {
+          // when request method is "OPTIONS" we must return a 200 without body
+          // So we bypass "requestToResponse" in that scenario using shortcircuitResponse
+          shortcircuitResponse({
+            status: 200,
+            headers: {
+              "content-length": 0,
+            },
+          })
+        }
+
+        return {
+          onResponse: () => {
+            const accessControlHeaders = generateAccessControlHeaders({
+              request,
+              accessControlAllowedOrigins,
+              accessControlAllowRequestOrigin,
+              accessControlAllowedMethods,
+              accessControlAllowRequestMethod,
+              accessControlAllowedHeaders,
+              accessControlAllowRequestHeaders,
+              accessControlAllowCredentials,
+              accessControlMaxAge,
+              timingAllowOrigin,
+            })
+
+            return {
+              headers: accessControlHeaders,
+            }
+          },
+        }
+      },
+    },
+  }
+}
+
+// https://www.w3.org/TR/cors/
+// https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS
+const generateAccessControlHeaders = ({
+  request: { headers },
+  accessControlAllowedOrigins,
+  accessControlAllowRequestOrigin,
+  accessControlAllowedMethods,
+  accessControlAllowRequestMethod,
+  accessControlAllowedHeaders,
+  accessControlAllowRequestHeaders,
+  accessControlAllowCredentials,
+  // by default OPTIONS request can be cache for a long time, it's not going to change soon ?
+  // we could put a lot here, see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Max-Age
+  accessControlMaxAge = 600,
+  timingAllowOrigin,
+} = {}) => {
+  const vary = []
+
+  const allowedOriginArray = [...accessControlAllowedOrigins]
+  if (accessControlAllowRequestOrigin) {
+    if ("origin" in headers && headers.origin !== "null") {
+      allowedOriginArray.push(headers.origin)
+      vary.push("origin")
+    } else if ("referer" in headers) {
+      allowedOriginArray.push(urlToOrigin(headers.referer))
+      vary.push("referer")
+    } else {
+      allowedOriginArray.push("*")
+    }
+  }
+
+  const allowedMethodArray = [...accessControlAllowedMethods]
+  if (
+    accessControlAllowRequestMethod &&
+    "access-control-request-method" in headers
+  ) {
+    const requestMethodName = headers["access-control-request-method"]
+    if (!allowedMethodArray.includes(requestMethodName)) {
+      allowedMethodArray.push(requestMethodName)
+      vary.push("access-control-request-method")
+    }
+  }
+
+  const allowedHeaderArray = [...accessControlAllowedHeaders]
+  if (
+    accessControlAllowRequestHeaders &&
+    "access-control-request-headers" in headers
+  ) {
+    const requestHeaderNameArray =
+      headers["access-control-request-headers"].split(", ")
+    requestHeaderNameArray.forEach((headerName) => {
+      const headerNameLowerCase = headerName.toLowerCase()
+      if (!allowedHeaderArray.includes(headerNameLowerCase)) {
+        allowedHeaderArray.push(headerNameLowerCase)
+        if (!vary.includes("access-control-request-headers")) {
+          vary.push("access-control-request-headers")
+        }
+      }
+    })
+  }
+
+  return {
+    "access-control-allow-origin": allowedOriginArray.join(", "),
+    "access-control-allow-methods": allowedMethodArray.join(", "),
+    "access-control-allow-headers": allowedHeaderArray.join(", "),
+    ...(accessControlAllowCredentials
+      ? { "access-control-allow-credentials": true }
+      : {}),
+    "access-control-max-age": accessControlMaxAge,
+    ...(timingAllowOrigin
+      ? { "timing-allow-origin": allowedOriginArray.join(", ") }
+      : {}),
+    ...(vary.length ? { vary: vary.join(", ") } : {}),
+  }
+}

package/src/fetchUrl.js

@@ -25,7 +25,9 @@ export const fetchUrl = async (
   try {
     url = String(new URL(url))
   } catch (e) {
-    throw new Error(`fetchUrl first argument must be an absolute url, received ${url}`)
+    throw new Error(
+      `fetchUrl first argument must be an absolute url, received ${url}`,
+    )
   }
 
   if (url.startsWith("file://")) {
@@ -48,12 +50,15 @@ export const fetchUrl = async (
       contentTypeMap,
       ...options,
     })
-    const response = new Response(typeof body === "string" ? Buffer.from(body) : body, {
-      url,
-      status,
-      statusText,
-      headers,
-    })
+    const response = new Response(
+      typeof body === "string" ? Buffer.from(body) : body,
+      {
+        url,
+        status,
+        statusText,
+        headers,
+      },
+    )
     return response
   }
 

package/src/findFreePort.js

@@ -1,5 +1,6 @@
-import { createServer } from "net"
+import { createServer } from "node:net"
 import { createCancellationToken } from "@jsenv/cancellation"
+
 import { listen } from "./internal/listen.js"
 
 export const findFreePort = async (

package/src/{composeResponse.js → internal/composeResponse.js}

@@ -1,5 +1,5 @@
-import { compositionMappingToComposeStrict } from "./internal/compositionMappingToComposeStrict.js"
-import { composeResponseHeaders } from "./internal/composeResponseHeaders.js"
+import { compositionMappingToComposeStrict } from "./compositionMappingToComposeStrict.js"
+import { composeResponseHeaders } from "./composeResponseHeaders.js"
 
 const responseCompositionMapping = {
   status: (prevStatus, status) => status,
@@ -12,4 +12,6 @@ const responseCompositionMapping = {
   },
 }
 
-export const composeResponse = compositionMappingToComposeStrict(responseCompositionMapping)
+export const composeResponse = compositionMappingToComposeStrict(
+  responseCompositionMapping,
+)

package/src/internal/compositionMappingToCompose.js

@@ -6,7 +6,9 @@ export const compositionMappingToCompose = (
   },
   { caseSensitive = true } = {},
 ) => {
-  const reducer = compositionMappingToReducer(compositionMapping, { caseSensitive })
+  const reducer = compositionMappingToReducer(compositionMapping, {
+    caseSensitive,
+  })
   return (...objects) => objects.reduce(reducer, createInitial())
 }
 
@@ -25,7 +27,12 @@ const compositionMappingToReducer = (compositionMapping, { caseSensitive }) => {
       const composedKey = caseSensitive ? key : key.toLowerCase()
       composed[composedKey] = caseSensitive
         ? composeProperty(key, previous, current, compositionMapping)
-        : composePropertyCaseInsensitive(key, previous, current, compositionMapping)
+        : composePropertyCaseInsensitive(
+            key,
+            previous,
+            current,
+            compositionMapping,
+          )
     })
     return composed
   }
@@ -42,16 +49,26 @@ const composeProperty = (key, previous, current, compositionMapping) => {
     return current[key]
   }
 
-  const keyExistingInComposer = keyExistsIn(key, compositionMapping) ? key : null
+  const keyExistingInComposer = keyExistsIn(key, compositionMapping)
+    ? key
+    : null
   if (!keyExistingInComposer) {
     return current[key]
   }
 
   const composerForProperty = compositionMapping[keyExistingInComposer]
-  return composerForProperty(previous[keyExistingInPrevious], current[keyExistingInCurrent])
+  return composerForProperty(
+    previous[keyExistingInPrevious],
+    current[keyExistingInCurrent],
+  )
 }
 
-const composePropertyCaseInsensitive = (key, previous, current, compositionMapping) => {
+const composePropertyCaseInsensitive = (
+  key,
+  previous,
+  current,
+  compositionMapping,
+) => {
   const keyLowercased = key.toLowerCase()
   const keyExistingInCurrent = keyExistsIn(key, current)
     ? key
@@ -80,7 +97,10 @@ const composePropertyCaseInsensitive = (key, previous, current, compositionMappi
   }
 
   const composerForProperty = compositionMapping[keyExistingInComposer]
-  return composerForProperty(previous[keyExistingInPrevious], current[keyExistingInCurrent])
+  return composerForProperty(
+    previous[keyExistingInPrevious],
+    current[keyExistingInCurrent],
+  )
 }
 
 const keyExistsIn = (key, object) => {