peakflow-api 0.0.0 → 0.0.1

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "peakflow-api",
-  "version": "0.0.0",
+  "version": "0.0.1",
   "type": "module",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "scripts": {
+    "all-checks": "npm run lint && npm run typecheck && npm test",
     "build": "tsc --project tsconfig.json && node scripts/minify.mjs",
     "lint": "eslint .",
     "release:patch": "npm version patch -m \"chore: release patch\" && git push origin master --follow-tags && npm publish",
@@ -13,7 +14,7 @@
   },
   "devDependencies": {
     "@kaspernj/api-maker": "^1.0.2062",
-    "@types/node": "^20.0.0",
+    "@types/node": "^20.19.27",
     "eslint": "^9.0.0",
     "eslint-plugin-jsdoc": "^48.0.0",
     "jasmine": "^5.1.0",

package/src/bug-reporting/index.js

@@ -35,9 +35,6 @@ export default class BugReporting {
     this.collectParamsCallback = callback
   }
 
-  /**
-   * Initialize global error handlers.
-   */
   /**
    * Initialize error handlers based on the runtime.
    */
@@ -241,7 +238,7 @@ export default class BugReporting {
 
   connectNodeUnhandledRejection() {
     globalThis.process.on("unhandledRejection", async (reason) => {
-      debuggerInstance.debug(`Unhandled rejection: ${JSON.stringify(reason?.message || reason)}`)
+      debuggerInstance.debug(`Unhandled rejection: ${JSON.stringify(reason instanceof Error ? reason.message : reason)}`)
 
       if (!this.isHandlingError) {
         this.isHandlingError = true
@@ -252,7 +249,7 @@ export default class BugReporting {
             errorClass: "UnhandledRejection",
             file: null,
             line: null,
-            message: reason?.message || String(reason),
+            message: reason instanceof Error ? reason.message : String(reason),
             url: null
           })
         } finally {
@@ -330,21 +327,15 @@ export default class BugReporting {
       debuggerInstance.debug("Resolved environment", postData.error.environment)
     }
 
-    if (typeof XMLHttpRequest === "undefined") {
-      debuggerInstance.debug("Skipping error report because XMLHttpRequest is unavailable")
+    const responseText = await this.sendErrorReport(postUrl, postData)
+
+    if (responseText == null) {
       return
     }
 
-    const xhr = new XMLHttpRequest()
-
-    xhr.open("POST", postUrl, true)
-    xhr.setRequestHeader("Content-Type", "application/json")
-
-    await this.loadXhr(xhr, JSON.stringify(postData))
+    debuggerInstance.debug(`Data received: ${responseText}`)
 
-    debuggerInstance.debug(`Data received: ${xhr.responseText}`)
-
-    const response = JSON.parse(digg(xhr, "responseText"))
+    const response = JSON.parse(digg({responseText}, "responseText"))
 
     // If the account has run out of bug reports, then this can potentially crash because 'url' wont be present.
     if (response.url) {
@@ -390,6 +381,77 @@ export default class BugReporting {
     })
   }
 
+  /**
+   * Send error report using the best available 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) {
+    const {request} = await import("node:https")
+    const {URL} = await import("node:url")
+
+    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()
+    })
+  }
+
   /**
    * Resolve environment data for a report.
    * @param {object} args

package/tsconfig.json

@@ -13,7 +13,7 @@
     "inlineSourceMap": true,
     "noEmitOnError": true,
     "strict": false,
-    "types": []
+    "types": ["node"]
   },
   "include": ["src/**/*.js"]
 }