peakflow-api 0.0.7 → 0.0.8

package/CHANGELOG.md

@@ -3,3 +3,9 @@
 - Chore: keep single-line JSDoc comments on a single line and document the convention.
 - Fix: defer runtime import helper creation to avoid CSP unsafe-eval during browser module load.
 - Fix: build Node module specifiers dynamically to avoid Expo bundler resolution errors.
+- Change: extract request transports into classes with selectable RequestClass fallback.
+- Change: validate BugReporting constructor options and reject unknown keys.
+- Change: validate RequestClass immediately in BugReporting constructor.
+- Test: cover XHR, fetch, and Node request transports.
+- Change: allow NodeRequest to accept a runtime import override for testing.
+- Chore: split request transport specs into dedicated files.

package/README.md

@@ -17,6 +17,19 @@ const bugReporting = new BugReporting({authToken: "your-token"})
 bugReporting.connect()
 ```
 
+## Request transport
+
+By default, BugReporting uses `XMLHttpRequest` when available, otherwise it falls back to `fetch`. If neither is available, you must provide a request class.
+
+```js
+import {BugReporting, NodeRequest} from "peakflow"
+
+const bugReporting = new BugReporting({
+  authToken: "your-token",
+  RequestClass: NodeRequest
+})
+```
+
 ## Browser error listeners
 
 ```js

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peakflow-api",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "type": "module",
   "main": "build/index.js",
   "types": "build/index.d.ts",

package/spec/bug-reporting.spec.js

@@ -162,4 +162,5 @@ describe("BugReporting", () => {
     }))
     expect(previousHandlerCalled).toBeTrue()
   })
+
 })

package/spec/requests/fetch-request.spec.js

@@ -0,0 +1,35 @@
+import FetchRequest from "../../src/bug-reporting/requests/fetch-request.js"
+
+describe("FetchRequest", () => {
+  const originalGlobals = {
+    fetch: globalThis.fetch
+  }
+
+  afterEach(() => {
+    globalThis.fetch = originalGlobals.fetch
+  })
+
+  it("sends requests with fetch", async () => {
+    let receivedUrl = null
+    let receivedOptions = null
+
+    globalThis.fetch = async (url, options) => {
+      receivedUrl = url
+      receivedOptions = options
+      return {
+        text: async () => "ok"
+      }
+    }
+
+    const request = new FetchRequest()
+    const responseText = await request.send("https://example.test/bugs", {hello: "world"})
+
+    expect(responseText).toBe("ok")
+    expect(receivedUrl).toBe("https://example.test/bugs")
+    expect(receivedOptions).toEqual({
+      method: "POST",
+      headers: {"Content-Type": "application/json"},
+      body: JSON.stringify({hello: "world"})
+    })
+  })
+})

package/spec/requests/node-request.spec.js

@@ -0,0 +1,61 @@
+import NodeRequest from "../../src/bug-reporting/requests/node-request.js"
+
+describe("NodeRequest", () => {
+  it("sends requests with the Node transport", async () => {
+    let requestOptions = null
+    let requestBody = null
+
+    const fakeRequest = (options, callback) => {
+      requestOptions = options
+      const res = {
+        setEncoding: () => {},
+        on: (event, handler) => {
+          if (event === "data") {
+            res.onData = handler
+          }
+          if (event === "end") {
+            res.onEnd = handler
+          }
+        }
+      }
+
+      callback(res)
+
+      return {
+        on: () => {},
+        write: (body) => {
+          requestBody = body
+        },
+        end: () => {
+          if (res.onData) {
+            res.onData("node-ok")
+          }
+          if (res.onEnd) {
+            res.onEnd()
+          }
+        }
+      }
+    }
+
+    const request = new NodeRequest({
+      runtimeImport: (specifier) => {
+        if (specifier === ["node", "https"].join(":")) {
+          return Promise.resolve({request: fakeRequest})
+        }
+        if (specifier === ["node", "url"].join(":")) {
+          return Promise.resolve({URL: globalThis.URL})
+        }
+        return Promise.reject(new Error(`Unexpected specifier: ${specifier}`))
+      }
+    })
+
+    const responseText = await request.send("https://example.test/path?q=1", {hello: "world"})
+
+    expect(responseText).toBe("node-ok")
+    expect(requestOptions).toEqual(jasmine.objectContaining({
+      method: "POST",
+      path: "/path?q=1"
+    }))
+    expect(requestBody).toBe(JSON.stringify({hello: "world"}))
+  })
+})

package/spec/requests/xhr-request.spec.js

@@ -0,0 +1,55 @@
+import XhrRequest from "../../src/bug-reporting/requests/xhr-request.js"
+
+describe("XhrRequest", () => {
+  const originalGlobals = {
+    XMLHttpRequest: globalThis.XMLHttpRequest
+  }
+
+  let lastXhr = null
+
+  class FakeXHR {
+    constructor() {
+      lastXhr = this
+      this.headers = {}
+      this.responseText = ""
+    }
+
+    open(method, url, async) {
+      this.method = method
+      this.url = url
+      this.async = async
+    }
+
+    setRequestHeader(key, value) {
+      this.headers[key] = value
+    }
+
+    send(body) {
+      this.requestBody = body
+      this.responseText = JSON.stringify({})
+      if (this.onload) {
+        this.onload()
+      }
+    }
+  }
+
+  beforeEach(() => {
+    globalThis.XMLHttpRequest = FakeXHR
+    lastXhr = null
+  })
+
+  afterEach(() => {
+    globalThis.XMLHttpRequest = originalGlobals.XMLHttpRequest
+  })
+
+  it("sends requests with XMLHttpRequest", async () => {
+    const request = new XhrRequest()
+    const responseText = await request.send("https://example.test/bugs", {hello: "world"})
+
+    expect(responseText).toBe("{}")
+    expect(lastXhr.method).toBe("POST")
+    expect(lastXhr.url).toBe("https://example.test/bugs")
+    expect(lastXhr.headers["Content-Type"]).toBe("application/json")
+    expect(lastXhr.requestBody).toBe(JSON.stringify({hello: "world"}))
+  })
+})

package/src/bug-reporting/index.js

@@ -4,21 +4,61 @@ import envSense from "env-sense"
 import RailsVariables from "./variables.js"
 import {debuggerInstance} from "../debugger.js"
 import SourceMapsLoader from "@kaspernj/api-maker/build/source-maps-loader.js"
+import XhrRequest from "./requests/xhr-request.js"
+import FetchRequest from "./requests/fetch-request.js"
+
+/**
+ * @typedef {{send: (postUrl: string, postData: object) => Promise<string|null>}} RequestHandler
+ */
+
+/**
+ * @typedef {new () => RequestHandler} RequestClass
+ */
 
 /**
  * Handles client-side error reporting for Peakflow.
  */
 export default class BugReporting {
   /**
-   * @param {{authToken: string}} data
+   * @param {{authToken: string, RequestClass?: RequestClass}} data
    */
   constructor(data) {
-    this.authToken = data.authToken
+    const {authToken, RequestClass, ...restArgs} = data || {}
+    const unknownKeys = Object.keys(restArgs)
+
+    if (unknownKeys.length) {
+      throw new Error(`Unknown BugReporting options: ${unknownKeys.join(", ")}`)
+    }
+
+    if (!authToken) {
+      throw new Error("BugReporting requires an authToken.")
+    }
+
+    this.authToken = authToken
     this.testing = false
     this.collectEnvironmentCallback = undefined
     this.collectParamsCallback = undefined
     this.sourceMapsLoader = null
     this.envSenseResult = null
+    this.requestHandler = null
+
+    if (RequestClass) {
+      if (typeof RequestClass !== "function") {
+        throw new Error("RequestClass must be a constructor.")
+      }
+
+      this.requestHandler = new RequestClass()
+
+      if (typeof this.requestHandler?.send !== "function") {
+        throw new Error("RequestClass must implement a send(postUrl, postData) method.")
+      }
+    } else if (typeof XMLHttpRequest !== "undefined") {
+      this.requestHandler = new XhrRequest()
+    } else if (typeof globalThis.fetch === "function") {
+      this.requestHandler = new FetchRequest()
+    } else {
+      throw new Error("No safe request transport is available. Provide RequestClass.")
+    }
   }
 
   /**
@@ -386,100 +426,13 @@ export default class BugReporting {
   }
 
   /**
-   * Send JSON data through an XHR instance.
-   * @param {XMLHttpRequest} xhr
-   * @param {string} postData
-   * @returns {Promise<void>}
-   */
-  loadXhr(xhr, postData) {
-    return new Promise((resolve) => {
-      xhr.onload = () => resolve()
-      xhr.send(postData)
-    })
-  }
-
-  /**
-   * Send error report using the best available transport.
+   * Send error report using the configured transport.
    * @param {string} postUrl
    * @param {object} postData
    * @returns {Promise<string|null>}
    */
   async sendErrorReport(postUrl, postData) {
-    const body = JSON.stringify(postData)
-
-    if (typeof XMLHttpRequest !== "undefined") {
-      const xhr = new XMLHttpRequest()
-
-      xhr.open("POST", postUrl, true)
-      xhr.setRequestHeader("Content-Type", "application/json")
-
-      await this.loadXhr(xhr, body)
-      return xhr.responseText
-    } else if (typeof globalThis.fetch === "function") {
-      const response = await globalThis.fetch(postUrl, {
-        method: "POST",
-        headers: {"Content-Type": "application/json"},
-        body
-      })
-
-      return await response.text()
-    } else if (this.isNode()) {
-      return await this.sendNodeRequest(postUrl, body)
-    }
-
-    debuggerInstance.debug("Skipping error report because no HTTP transport is available")
-    return null
-  }
-
-  /**
-   * Send an HTTP request using Node's built-in modules.
-   * @param {string} postUrl
-   * @param {string} body
-   * @returns {Promise<string|null>}
-   */
-  async sendNodeRequest(postUrl, body) {
-    /** @type {(specifier: string) => Promise<unknown>} */
-    const runtimeImport = (specifier) => {
-      const loader = new Function("specifier", "return import(specifier)")
-      return loader(specifier)
-    }
-
-    const httpsSpecifier = ["node", "https"].join(":")
-    const urlSpecifier = ["node", "url"].join(":")
-
-    const {request} = /** @type {{request: typeof import("node:https").request}} */ (
-      await runtimeImport(httpsSpecifier)
-    )
-    const {URL} = /** @type {{URL: typeof import("node:url").URL}} */ (
-      await runtimeImport(urlSpecifier)
-    )
-
-    return await new Promise((resolve) => {
-      const url = new URL(postUrl)
-
-      const req = request({
-        protocol: url.protocol,
-        hostname: url.hostname,
-        port: url.port || (url.protocol === "https:" ? 443 : 80),
-        path: `${url.pathname}${url.search}`,
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "Content-Length": Buffer.byteLength(body)
-        }
-      }, (res) => {
-        let data = ""
-        res.setEncoding("utf8")
-        res.on("data", (chunk) => {
-          data += chunk
-        })
-        res.on("end", () => resolve(data))
-      })
-
-      req.on("error", () => resolve(null))
-      req.write(body)
-      req.end()
-    })
+    return await this.requestHandler.send(postUrl, postData)
   }
 
   /**

package/src/bug-reporting/requests/fetch-request.js

@@ -0,0 +1,21 @@
+/** Send JSON payloads with fetch. */
+export default class FetchRequest {
+  /**
+   * @param {string} postUrl
+   * @param {object} postData
+   * @returns {Promise<string|null>}
+   */
+  async send(postUrl, postData) {
+    if (typeof globalThis.fetch !== "function") {
+      throw new Error("fetch is not available in this environment.")
+    }
+
+    const response = await globalThis.fetch(postUrl, {
+      method: "POST",
+      headers: {"Content-Type": "application/json"},
+      body: JSON.stringify(postData)
+    })
+
+    return await response.text()
+  }
+}

package/src/bug-reporting/requests/node-request.js

@@ -0,0 +1,62 @@
+/** Send JSON payloads with Node's https module. */
+export default class NodeRequest {
+  /**
+   * @param {{runtimeImport?: (specifier: string) => Promise<unknown>}} [options]
+   */
+  constructor(options = {}) {
+    if (options.runtimeImport) {
+      this.runtimeImport = options.runtimeImport
+    } else {
+      this.runtimeImport = (specifier) => {
+        const loader = new Function("specifier", "return import(specifier)")
+        return loader(specifier)
+      }
+    }
+  }
+
+  /**
+   * @param {string} postUrl
+   * @param {object} postData
+   * @returns {Promise<string|null>}
+   */
+  async send(postUrl, postData) {
+    const httpsSpecifier = ["node", "https"].join(":")
+    const urlSpecifier = ["node", "url"].join(":")
+
+    const {request} = /** @type {{request: typeof import("node:https").request}} */ (
+      await this.runtimeImport(httpsSpecifier)
+    )
+    const {URL} = /** @type {{URL: typeof import("node:url").URL}} */ (
+      await this.runtimeImport(urlSpecifier)
+    )
+
+    const body = JSON.stringify(postData)
+
+    return await new Promise((resolve) => {
+      const url = new URL(postUrl)
+
+      const req = request({
+        protocol: url.protocol,
+        hostname: url.hostname,
+        port: url.port || (url.protocol === "https:" ? 443 : 80),
+        path: `${url.pathname}${url.search}`,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(body)
+        }
+      }, (res) => {
+        let data = ""
+        res.setEncoding("utf8")
+        res.on("data", (chunk) => {
+          data += chunk
+        })
+        res.on("end", () => resolve(data))
+      })
+
+      req.on("error", () => resolve(null))
+      req.write(body)
+      req.end()
+    })
+  }
+}

package/src/bug-reporting/requests/xhr-request.js

@@ -0,0 +1,25 @@
+/** Send JSON payloads with XMLHttpRequest. */
+export default class XhrRequest {
+  /**
+   * @param {string} postUrl
+   * @param {object} postData
+   * @returns {Promise<string|null>}
+   */
+  async send(postUrl, postData) {
+    if (typeof XMLHttpRequest === "undefined") {
+      throw new Error("XMLHttpRequest is not available in this environment.")
+    }
+
+    const xhr = new XMLHttpRequest()
+
+    xhr.open("POST", postUrl, true)
+    xhr.setRequestHeader("Content-Type", "application/json")
+
+    await new Promise((resolve) => {
+      xhr.onload = () => resolve()
+      xhr.send(JSON.stringify(postData))
+    })
+
+    return xhr.responseText
+  }
+}