botversion-sdk 1.0.5 → 1.1.6

package/interceptor.js

@@ -1,109 +1,7 @@
 // botversion-sdk/interceptor.js
 "use strict";
 
-/**
- * Makes an internal HTTP request to the user's own backend.
- * Forwards cookies, auth headers, and CSRF tokens.
- */
-function makeInternalRequest(method, path, body, cookies, headers, baseUrl) {
-  return new Promise(function (resolve) {
-    var http = require("http");
-    var https = require("https");
-    var url = require("url");
-
-    baseUrl = baseUrl || "http://127.0.0.1:8000";
-    var fullUrl = baseUrl + path;
-    var parsedUrl = url.parse(fullUrl);
-    var isHttps = parsedUrl.protocol === "https:";
-    var lib = isHttps ? https : http;
-
-    var bodyStr = body ? JSON.stringify(body) : null;
-
-    var reqHeaders = {
-      "Content-Type": "application/json",
-    };
-
-    if (bodyStr) {
-      reqHeaders["Content-Length"] = String(Buffer.byteLength(bodyStr));
-    }
-
-    // Forward cookies — this is what identifies the user
-    if (cookies) reqHeaders["Cookie"] = cookies;
-
-    // Forward auth header
-    var authHeader =
-      headers && (headers["authorization"] || headers["Authorization"]);
-    if (authHeader) reqHeaders["Authorization"] = authHeader;
-
-    // Forward CSRF token
-    var csrf =
-      headers &&
-      (headers["x-csrftoken"] ||
-        headers["X-CSRFToken"] ||
-        headers["x-xsrf-token"] ||
-        headers["X-XSRF-TOKEN"]);
-    if (csrf) reqHeaders["X-CSRFToken"] = csrf;
-
-    var reqOptions = {
-      hostname: parsedUrl.hostname,
-      port: parsedUrl.port || (isHttps ? 443 : 80),
-      path: parsedUrl.path,
-      method: method.toUpperCase(),
-      headers: reqHeaders,
-      timeout: 30000,
-    };
-
-    var req = lib.request(reqOptions, function (res) {
-      var data = "";
-      res.on("data", function (chunk) {
-        data += chunk;
-      });
-      res.on("end", function () {
-        var parsed;
-        try {
-          parsed = JSON.parse(data);
-        } catch (e) {
-          parsed = { raw: data };
-        }
-
-        // Handle redirects
-        if (
-          res.statusCode >= 300 &&
-          res.statusCode < 400 &&
-          res.headers.location
-        ) {
-          makeInternalRequest(
-            res.statusCode === 303 ? "GET" : method,
-            res.headers.location,
-            res.statusCode === 303 ? null : body,
-            cookies,
-            headers,
-            baseUrl,
-          ).then(resolve);
-          return;
-        }
-
-        resolve({
-          status: res.statusCode,
-          ok: res.statusCode >= 200 && res.statusCode < 300,
-          data: parsed,
-        });
-      });
-    });
-
-    req.on("error", function (err) {
-      resolve({ status: 500, ok: false, data: { error: err.message } });
-    });
-
-    req.on("timeout", function () {
-      req.destroy();
-      resolve({ status: 500, ok: false, data: { error: "Request timed out" } });
-    });
-
-    if (bodyStr) req.write(bodyStr);
-    req.end();
-  });
-}
+const reportedEndpoints = new Set();
 
 /**
  * Attaches a middleware to the Express app that
@@ -120,11 +18,9 @@ function attachInterceptor(app, client, options) {
     "/_next",
     "/static",
     "/public",
+    "/admin",
   ].concat(options.exclude || []);
 
-  // Track which endpoints we have already reported
-  const reportedEndpoints = new Set();
-
   app.use(function botVersionInterceptor(req, res, next) {
     const path = req.path || req.url || "";
     const shouldIgnore = ignorePaths.some(function (p) {
@@ -182,23 +78,12 @@ function attachInterceptor(app, client, options) {
             requestBody: jsonSchema,
             detectedBy: "runtime",
           })
-          .catch(function (err) {
-            if (options.debug) {
-              console.warn(
-                "[BotVersion SDK] Failed to report endpoint:",
-                err.message,
-              );
-            }
-          });
+          .catch(function (err) {});
       });
     }
 
     next();
   });
-  // Register executor so WebSocket can forward calls to user's backend
-  client.setExecutor(function (method, path, body, cookies, headers, baseUrl) {
-    return makeInternalRequest(method, path, body, cookies, headers, baseUrl);
-  });
 }
 
 /**
@@ -286,8 +171,456 @@ function buildBodyStructure(body) {
   return structure;
 }
 
+function attachNextJsInterceptor(client, options) {
+  try {
+    const http = require("http");
+    const originalEmit = http.Server.prototype.emit;
+
+    http.Server.prototype.emit = function (event, req, res) {
+      if (event === "request") {
+        const path = req.url ? req.url.split("?")[0] : "";
+        const method = req.method ? req.method.toUpperCase() : "";
+
+        const shouldIgnore = (options.exclude || [])
+          .concat([
+            "/health",
+            "/favicon.ico",
+            "/_next",
+            "/static",
+            "/public",
+            "/admin",
+          ])
+          .some(function (p) {
+            return path.startsWith(p);
+          });
+
+        const isApiPath = path.startsWith(options.apiPrefix || "/api");
+
+        if (!shouldIgnore && isApiPath) {
+          const normalizedPath = normalizePath(path);
+          const endpointKey = method + ":" + normalizedPath;
+
+          if (!reportedEndpoints.has(endpointKey)) {
+            reportedEndpoints.add(endpointKey);
+
+            // Skip file uploads — too large and not JSON
+            const contentType = req.headers["content-type"] || "";
+            if (contentType.includes("multipart/form-data")) {
+              client
+                .updateEndpoint({
+                  method: method,
+                  path: normalizedPath,
+                  requestBody: null,
+                  detectedBy: "runtime",
+                })
+                .catch(function () {});
+              return originalEmit.apply(this, arguments);
+            }
+
+            // Helper to send body structure to platform
+            function reportBody(bodyObj) {
+              try {
+                let parsedBody = null;
+                const structure = buildBodyStructure(bodyObj);
+                if (structure) {
+                  parsedBody = {
+                    type: "object",
+                    properties: Object.fromEntries(
+                      Object.entries(structure).map(([key, type]) => [
+                        key,
+                        {
+                          type:
+                            type === "null" || type === "[redacted]"
+                              ? "string"
+                              : type,
+                        },
+                      ]),
+                    ),
+                  };
+                }
+                client
+                  .updateEndpoint({
+                    method: method,
+                    path: normalizedPath,
+                    requestBody: parsedBody,
+                    detectedBy: "runtime",
+                  })
+                  .catch(function () {});
+              } catch (e) {}
+            }
+
+            // APP ROUTER — req.body is a Web Stream, read it early
+            // and put it back as a new stream so App Router can still read it
+            if (
+              typeof req.body !== "undefined" &&
+              req.body &&
+              typeof req.body.getReader === "function"
+            ) {
+              try {
+                const reader = req.body.getReader();
+                const chunks = [];
+                function readChunk() {
+                  reader
+                    .read()
+                    .then(function (result) {
+                      if (result.done) {
+                        const fullBuffer = Buffer.concat(
+                          chunks.map(function (c) {
+                            return Buffer.from(c);
+                          }),
+                        );
+                        // Put the body back as a new ReadableStream
+                        const { ReadableStream } = require("stream/web");
+                        req.body = new ReadableStream({
+                          start: function (controller) {
+                            controller.enqueue(fullBuffer);
+                            controller.close();
+                          },
+                        });
+                        // Parse and report
+                        try {
+                          const parsed = JSON.parse(fullBuffer.toString());
+                          reportBody(parsed);
+                        } catch (e) {}
+                      } else {
+                        chunks.push(result.value);
+                        readChunk();
+                      }
+                    })
+                    .catch(function () {});
+                }
+                readChunk();
+              } catch (e) {}
+              return originalEmit.apply(this, arguments);
+            }
+
+            // PAGES ROUTER — req.body is populated by Next.js after parsing
+            // We intercept res.end because by then req.body is fully available
+            const originalResEnd = res.end.bind(res);
+            res.end = function (chunk, encoding, callback) {
+              reportBody(req.body || null);
+              return originalResEnd(chunk, encoding, callback);
+            };
+          }
+        }
+      }
+
+      return originalEmit.apply(this, arguments);
+    };
+  } catch (err) {}
+}
+
+/**
+ * Attaches a Fastify hook that silently intercepts every request
+ * and reports new endpoints to BotVersion platform.
+ */
+function attachFastifyInterceptor(fastify, client, options) {
+  options = options || {};
+
+  const ignorePaths = [
+    "/health",
+    "/favicon.ico",
+    "/_next",
+    "/static",
+    "/public",
+    "/admin",
+  ].concat(options.exclude || []);
+
+  fastify.addHook("onRequest", async function (request, reply) {
+    const path = request.url ? request.url.split("?")[0] : "";
+    const method = request.method ? request.method.toUpperCase() : "";
+
+    const shouldIgnore = ignorePaths.some(function (p) {
+      return path.startsWith(p);
+    });
+
+    if (shouldIgnore) return;
+
+    if (options.apiPrefix && !path.startsWith(options.apiPrefix)) return;
+
+    const normalizedPath = normalizePath(path);
+    const endpointKey = method + ":" + normalizedPath;
+
+    if (!reportedEndpoints.has(endpointKey)) {
+      reportedEndpoints.add(endpointKey);
+
+      setImmediate(function () {
+        client
+          .updateEndpoint({
+            method,
+            path: normalizedPath,
+            requestBody: null,
+            detectedBy: "runtime-fastify",
+          })
+          .catch(function () {});
+      });
+    }
+  });
+
+  // Use onSend hook to capture body after parsing
+  fastify.addHook("preHandler", async function (request, reply) {
+    const path = request.url ? request.url.split("?")[0] : "";
+    const method = request.method ? request.method.toUpperCase() : "";
+    const normalizedPath = normalizePath(path);
+    const bodyKey = method + ":" + normalizedPath + ":body";
+
+    if (reportedEndpoints.has(bodyKey)) return;
+    reportedEndpoints.add(bodyKey);
+
+    const body = request.body;
+    if (!body) return;
+
+    const bodyStructure = buildBodyStructure(body);
+    if (!bodyStructure) return;
+
+    const jsonSchema = {
+      type: "object",
+      properties: Object.fromEntries(
+        Object.entries(bodyStructure).map(function ([key, type]) {
+          return [
+            key,
+            {
+              type: type === "null" || type === "[redacted]" ? "string" : type,
+            },
+          ];
+        }),
+      ),
+    };
+
+    setImmediate(function () {
+      client
+        .updateEndpoint({
+          method,
+          path: normalizedPath,
+          requestBody: jsonSchema,
+          detectedBy: "runtime-fastify",
+        })
+        .catch(function () {});
+    });
+  });
+}
+
+/**
+ * Attaches a Koa middleware that silently intercepts every request
+ * and reports new endpoints to BotVersion platform.
+ */
+function attachKoaInterceptor(app, client, options) {
+  options = options || {};
+
+  const ignorePaths = [
+    "/health",
+    "/favicon.ico",
+    "/_next",
+    "/static",
+    "/public",
+    "/admin",
+  ].concat(options.exclude || []);
+
+  // IMPORTANT: This interceptor must be added AFTER koa-bodyparser middleware
+  // so that ctx.request.body is already populated when we read it.
+  app.use(async function botVersionKoaInterceptor(ctx, next) {
+    await next();
+
+    const path = ctx.path || "";
+    const method = ctx.method ? ctx.method.toUpperCase() : "";
+
+    const shouldIgnore = ignorePaths.some(function (p) {
+      return path.startsWith(p);
+    });
+
+    if (shouldIgnore) return;
+
+    if (options.apiPrefix && !path.startsWith(options.apiPrefix)) return;
+
+    const normalizedPath = normalizePath(path);
+    const endpointKey = method + ":" + normalizedPath;
+
+    const body = ctx.request.body;
+    const bodyStructure = buildBodyStructure(body);
+    const bodyKey =
+      endpointKey +
+      ":" +
+      Object.keys(bodyStructure || {})
+        .sort()
+        .join(",");
+
+    if (!reportedEndpoints.has(bodyKey)) {
+      reportedEndpoints.add(bodyKey);
+
+      const jsonSchema = bodyStructure
+        ? {
+            type: "object",
+            properties: Object.fromEntries(
+              Object.entries(bodyStructure).map(function ([key, type]) {
+                return [
+                  key,
+                  {
+                    type:
+                      type === "null" || type === "[redacted]"
+                        ? "string"
+                        : type,
+                  },
+                ];
+              }),
+            ),
+          }
+        : null;
+
+      setImmediate(function () {
+        client
+          .updateEndpoint({
+            method,
+            path: normalizedPath,
+            requestBody: jsonSchema,
+            detectedBy: "runtime-koa",
+          })
+          .catch(function () {});
+      });
+    }
+  });
+}
+
+/**
+ * Attaches a Hapi lifecycle extension that silently intercepts every request
+ * and reports new endpoints to BotVersion platform.
+ */
+function attachHapiInterceptor(server, client, options) {
+  options = options || {};
+
+  const ignorePaths = [
+    "/health",
+    "/favicon.ico",
+    "/_next",
+    "/static",
+    "/public",
+    "/admin",
+  ].concat(options.exclude || []);
+
+  server.ext("onPostAuth", function (request, h) {
+    const path = request.path || "";
+    const method = request.method ? request.method.toUpperCase() : "";
+
+    const shouldIgnore = ignorePaths.some(function (p) {
+      return path.startsWith(p);
+    });
+
+    if (shouldIgnore) return h.continue;
+
+    if (options.apiPrefix && !path.startsWith(options.apiPrefix))
+      return h.continue;
+
+    const normalizedPath = normalizePath(path);
+    const endpointKey = method + ":" + normalizedPath;
+
+    const body = request.payload;
+    const bodyStructure = buildBodyStructure(body);
+    const bodyKey =
+      endpointKey +
+      ":" +
+      Object.keys(bodyStructure || {})
+        .sort()
+        .join(",");
+
+    if (!reportedEndpoints.has(bodyKey)) {
+      reportedEndpoints.add(bodyKey);
+
+      const jsonSchema = bodyStructure
+        ? {
+            type: "object",
+            properties: Object.fromEntries(
+              Object.entries(bodyStructure).map(function ([key, type]) {
+                return [
+                  key,
+                  {
+                    type:
+                      type === "null" || type === "[redacted]"
+                        ? "string"
+                        : type,
+                  },
+                ];
+              }),
+            ),
+          }
+        : null;
+
+      setImmediate(function () {
+        client
+          .updateEndpoint({
+            method,
+            path: normalizedPath,
+            requestBody: jsonSchema,
+            detectedBy: "runtime-hapi",
+          })
+          .catch(function () {});
+      });
+    }
+
+    return h.continue;
+  });
+}
+
+/**
+ * Attaches a NestJS interceptor by patching the underlying http server.
+ * NestJS runs on top of Express or Fastify under the hood so we can
+ * patch the Node http server the same way we do for Next.js.
+ */
+function attachNestJsInterceptor(client, options) {
+  // NestJS runs on Node http server under the hood
+  // So we reuse the same approach as Next.js
+  attachNextJsInterceptor(client, {
+    exclude: (options || {}).exclude || [],
+    apiPrefix: (options || {}).apiPrefix || "/",
+    debug: (options || {}).debug || false,
+  });
+}
+
+/**
+ * SvelteKit, Nuxt and Remix all run on Node http server
+ * so we reuse the Next.js interceptor approach for all of them.
+ */
+function attachSvelteKitInterceptor(client, options) {
+  attachNextJsInterceptor(client, {
+    exclude: (options || {}).exclude || [],
+    apiPrefix: (options || {}).apiPrefix || "/",
+    debug: (options || {}).debug || false,
+  });
+}
+
+function attachNuxtInterceptor(client, options) {
+  attachNextJsInterceptor(client, {
+    exclude: (options || {}).exclude || [],
+    apiPrefix: (options || {}).apiPrefix || "/api",
+    debug: (options || {}).debug || false,
+  });
+}
+
+function attachRemixInterceptor(client, options) {
+  attachNextJsInterceptor(client, {
+    exclude: (options || {}).exclude || [],
+    apiPrefix: (options || {}).apiPrefix || "/",
+    debug: (options || {}).debug || false,
+  });
+}
+
+function attachAdonisInterceptor(client, options) {
+  attachNextJsInterceptor(client, {
+    exclude: (options || {}).exclude || [],
+    apiPrefix: (options || {}).apiPrefix || "/",
+    debug: (options || {}).debug || false,
+  });
+}
+
 module.exports = {
   attachInterceptor,
+  attachNextJsInterceptor,
+  attachFastifyInterceptor,
+  attachKoaInterceptor,
+  attachHapiInterceptor,
+  attachNestJsInterceptor,
+  attachSvelteKitInterceptor,
+  attachNuxtInterceptor,
+  attachRemixInterceptor,
+  attachAdonisInterceptor,
   normalizePath,
   buildBodyStructure,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "botversion-sdk",
-  "version": "1.0.5",
+  "version": "1.1.6",
   "description": "BotVersion SDK — auto-detect and register your API endpoints",
   "main": "index.js",
   "bin": {
@@ -16,7 +16,8 @@
   "author": "Saurav Dhakal",
   "license": "MIT",
   "dependencies": {
-    "express": "^4.18.2",
-    "ws": "^8.20.0"
+    "@babel/parser": "^7.29.3",
+    "@babel/traverse": "^7.29.0",
+    "express": "^4.18.2"
   }
 }