botversion-sdk 1.0.5 → 1.1.6

package/index.js

@@ -1,10 +1,266 @@
-// botversion-sdk/index.js
 "use strict";
 
 var scanner = require("./scanner");
 var interceptor = require("./interceptor");
 var BotVersionClient = require("./client");
 
+// ── Framework auto-detection ─────────────────────────────────────────────────
+// Reads package.json from the customer's codebase and figures out
+// which backend and frontend frameworks they are using.
+function detectFrameworks(cwd) {
+  const fs = require("fs");
+  const path = require("path");
+
+  const result = {
+    backend: "unknown",
+    frontend: "unknown",
+  };
+
+  let pkg = {};
+  try {
+    const pkgPath = path.join(cwd, "package.json");
+    if (fs.existsSync(pkgPath)) {
+      pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+    }
+  } catch {
+    return result;
+  }
+
+  const deps = Object.assign(
+    {},
+    pkg.dependencies || {},
+    pkg.devDependencies || {},
+  );
+
+  // ── Backend detection ──────────────────────────────────────────────────────
+  if (deps["@nestjs/core"]) {
+    result.backend = "nestjs";
+  } else if (deps["fastify"]) {
+    result.backend = "fastify";
+  } else if (deps["@adonisjs/core"]) {
+    result.backend = "adonis";
+  } else if (deps["@hapi/hapi"] || deps["hapi"]) {
+    result.backend = "hapi";
+  } else if (deps["koa"]) {
+    result.backend = "koa";
+  } else if (deps["next"]) {
+    result.backend = "nextjs";
+  } else if (deps["express"]) {
+    result.backend = "express";
+  } else if (deps["@remix-run/node"] || deps["@remix-run/serve"]) {
+    result.backend = "remix";
+  } else if (deps["nuxt"] || deps["nuxt3"] || deps["@nuxt/core"]) {
+    result.backend = "nuxt";
+  } else if (deps["@sveltejs/kit"]) {
+    result.backend = "sveltekit";
+  }
+
+  // ── Frontend detection ─────────────────────────────────────────────────────
+  if (deps["next"]) {
+    result.frontend = "nextjs";
+  } else if (deps["nuxt"] || deps["nuxt3"] || deps["@nuxt/core"]) {
+    result.frontend = "nuxt";
+  } else if (deps["@sveltejs/kit"]) {
+    result.frontend = "sveltekit";
+  } else if (deps["@remix-run/react"]) {
+    result.frontend = "remix";
+  } else if (deps["@tanstack/router"] || deps["@tanstack/react-router"]) {
+    result.frontend = "tanstack";
+  } else if (deps["vue"] && (deps["vue-router"] || deps["@nuxtjs/router"])) {
+    result.frontend = "vue";
+  } else if (deps["@angular/core"]) {
+    result.frontend = "angular";
+  } else if (deps["svelte"]) {
+    result.frontend = "svelte";
+  } else if (deps["react"] && deps["react-router-dom"]) {
+    result.frontend = "react-router";
+  } else if (deps["astro"]) {
+    result.frontend = "astro";
+  } else if (deps["react"]) {
+    result.frontend = "react";
+  }
+
+  return result;
+}
+
+// ── Run the right backend scanner ────────────────────────────────────────────
+function runBackendScanner(detectedBackend, app, options, cwd) {
+  const endpoints = [];
+
+  switch (detectedBackend) {
+    case "express":
+      endpoints.push(...scanner.scanExpressRoutes(app, cwd));
+      break;
+
+    case "nextjs": {
+      const fs = require("fs");
+      const path = require("path");
+
+      const possibleAppDirs = [
+        path.join(cwd, "app"),
+        path.join(cwd, "src", "app"),
+      ];
+      const possiblePagesDirs = [
+        path.join(cwd, "pages"),
+        path.join(cwd, "src", "pages"),
+      ];
+
+      for (const dir of possibleAppDirs) {
+        if (fs.existsSync(dir)) {
+          endpoints.push(...scanner.scanNextJsAppRoutes(dir));
+        }
+      }
+      for (const dir of possiblePagesDirs) {
+        if (fs.existsSync(dir)) {
+          endpoints.push(...scanner.scanNextJsRoutes(dir));
+        }
+      }
+      break;
+    }
+
+    case "fastify":
+      endpoints.push(...scanner.scanFastifyRoutes(cwd));
+      break;
+
+    case "nestjs":
+      endpoints.push(...scanner.scanNestJsRoutes(cwd));
+      break;
+
+    case "koa":
+      endpoints.push(...scanner.scanKoaRoutes(cwd));
+      break;
+
+    case "hapi":
+      endpoints.push(...scanner.scanHapiRoutes(cwd));
+      break;
+
+    case "adonis":
+      endpoints.push(...scanner.scanAdonisRoutes(cwd));
+      break;
+
+    case "nuxt":
+      endpoints.push(...scanner.scanNuxtServerRoutes(cwd));
+      break;
+
+    case "sveltekit":
+      endpoints.push(...scanner.scanSvelteKitServerRoutes(cwd));
+      break;
+
+    case "remix":
+      endpoints.push(...scanner.scanRemixServerRoutes(cwd));
+      break;
+
+    default:
+      // Unknown backend — try Express as best guess
+      if (app) {
+        endpoints.push(...scanner.scanExpressRoutes(app, cwd));
+      }
+      break;
+  }
+
+  return endpoints;
+}
+
+// ── Attach the right runtime interceptor ─────────────────────────────────────
+function attachRuntimeInterceptor(detectedBackend, app, client, options) {
+  switch (detectedBackend) {
+    case "express":
+      interceptor.attachInterceptor(app, client, {
+        exclude: options.exclude || [],
+        apiPrefix: options.apiPrefix || null,
+        debug: options.debug || false,
+      });
+      break;
+
+    case "nextjs":
+      interceptor.attachNextJsInterceptor(client, {
+        exclude: options.exclude || [],
+        apiPrefix: options.apiPrefix || "/api",
+        debug: options.debug || false,
+      });
+      break;
+
+    case "fastify":
+      if (app) {
+        interceptor.attachFastifyInterceptor(app, client, {
+          exclude: options.exclude || [],
+          apiPrefix: options.apiPrefix || null,
+          debug: options.debug || false,
+        });
+      }
+      break;
+
+    case "koa":
+      if (app) {
+        interceptor.attachKoaInterceptor(app, client, {
+          exclude: options.exclude || [],
+          apiPrefix: options.apiPrefix || null,
+          debug: options.debug || false,
+        });
+      }
+      break;
+
+    case "hapi":
+      if (app) {
+        interceptor.attachHapiInterceptor(app, client, {
+          exclude: options.exclude || [],
+          apiPrefix: options.apiPrefix || null,
+          debug: options.debug || false,
+        });
+      }
+      break;
+
+    case "nestjs":
+      interceptor.attachNestJsInterceptor(client, {
+        exclude: options.exclude || [],
+        apiPrefix: options.apiPrefix || "/",
+        debug: options.debug || false,
+      });
+      break;
+
+    case "sveltekit":
+      interceptor.attachSvelteKitInterceptor(client, {
+        exclude: options.exclude || [],
+        apiPrefix: options.apiPrefix || "/",
+        debug: options.debug || false,
+      });
+      break;
+
+    case "nuxt":
+      interceptor.attachNuxtInterceptor(client, {
+        exclude: options.exclude || [],
+        apiPrefix: options.apiPrefix || "/api",
+        debug: options.debug || false,
+      });
+      break;
+
+    case "remix":
+      interceptor.attachRemixInterceptor(client, {
+        exclude: options.exclude || [],
+        apiPrefix: options.apiPrefix || "/",
+        debug: options.debug || false,
+      });
+      break;
+
+    case "adonis":
+      interceptor.attachAdonisInterceptor(client, {
+        exclude: options.exclude || [],
+        apiPrefix: options.apiPrefix || "/",
+        debug: options.debug || false,
+      });
+      break;
+
+    default:
+      // Unknown — fall back to Next.js http server patch as best guess
+      interceptor.attachNextJsInterceptor(client, {
+        exclude: options.exclude || [],
+        apiPrefix: options.apiPrefix || "/",
+        debug: options.debug || false,
+      });
+      break;
+  }
+}
+
 var BotVersion = {
   _client: null,
   _initialized: false,
@@ -26,22 +282,14 @@ var BotVersion = {
       app = null;
     }
 
-    if (!options.apiKey) {
-      console.error("[BotVersion SDK] ❌ apiKey is required.");
-      return;
-    }
-
     // Restore from global if module was re-imported after hot reload
     if (global._botVersionClient) {
       this._client = global._botVersionClient;
       this._options = global._botVersionOptions;
       this._initialized = true;
-      console.warn("[BotVersion SDK] Restored from global — skipping re-init");
-      return;
-    }
-
-    if (this._initialized) {
-      console.warn("[BotVersion SDK] Already initialized — skipping");
+      const savedOptions = global._botVersionOptions || {};
+      const savedFramework = global._botVersionFramework || "nextjs";
+      attachRuntimeInterceptor(savedFramework, app, this._client, savedOptions);
       return;
     }
 
@@ -51,7 +299,7 @@ var BotVersion = {
 
     this._client = new BotVersionClient({
       apiKey: options.apiKey,
-      platformUrl: options.platformUrl || "http://localhost:3000",
+      platformUrl: options.platformUrl || "https://botversion.com",
       debug: options.debug || false,
       timeout: options.timeout || 30000,
     });
@@ -60,185 +308,44 @@ var BotVersion = {
     global._botVersionOptions = options;
 
     var self = this;
+    var cwd = options.cwd || process.cwd();
     var debug = options.debug || false;
 
-    if (debug) {
-      console.log("[BotVersion SDK] Initializing...");
-      if (app) {
-        console.log("[BotVersion SDK] Mode: Express");
-      } else {
-        console.log("[BotVersion SDK] Mode: Next.js (file-based routing)");
-      }
-    }
+    // ── Auto-detect frameworks ───────────────────────────────────────────────
+    var detected = detectFrameworks(cwd);
 
-    // ── Framework detection ──────────────────────────────────────────────────
-    if (app) {
-      var frameworkCheck = detectFramework(app);
-      if (!frameworkCheck.supported) {
-        console.error(
-          "[BotVersion SDK] ❌ Unsupported framework:",
-          frameworkCheck.name,
-        );
-        console.error(
-          "[BotVersion SDK] ❌ Currently supports Express and Next.js only.",
-        );
-        return;
-      }
-      if (debug) {
-        console.log(
-          "[BotVersion SDK] ✅ Framework detected:",
-          frameworkCheck.name,
-        );
-      }
-    }
+    // Allow manual override from options
+    var detectedBackend = options.framework || detected.backend;
+    var detectedFrontend = options.frontendFramework || detected.frontend;
 
-    // ── Runtime interceptor — Express only ───────────────────────────────────
-    if (app && app.use) {
-      interceptor.attachInterceptor(app, self._client, {
-        exclude: options.exclude || [],
-        apiPrefix: options.apiPrefix || null,
-        debug: debug,
-      });
-      if (debug) {
-        console.log("[BotVersion SDK] ✅ Runtime interceptor attached");
-      }
-    } else if (!app) {
-      if (debug) {
-        console.log(
-          "[BotVersion SDK] ℹ Runtime interceptor skipped — Next.js mode uses file scanning only",
-        );
-      }
+    global._botVersionFramework = detectedBackend;
+
+    if (debug) {
+      // Detected: detectedBackend, detectedFrontend
     }
 
+    // ── Attach runtime interceptor ───────────────────────────────────────────
+    attachRuntimeInterceptor(detectedBackend, app, self._client, options);
+
     // ── Static scan ──────────────────────────────────────────────────────────
     setTimeout(function () {
-      var endpoints = [];
-
-      // Express scan
-      // Express scan
-      if (app) {
-        console.log("[BotVersion SDK] Scanning Express routes...");
-        var cwd = options.cwd || process.cwd();
-        endpoints = scanner.scanExpressRoutes(app, cwd);
-        console.log(
-          "[BotVersion SDK] Found",
-          endpoints.length,
-          "Express routes",
-        );
-
-        if (endpoints.length === 0) {
-          console.warn("[BotVersion SDK] ⚠ No endpoints found.");
-          console.warn(
-            "[BotVersion SDK] ⚠ Make sure routes are defined BEFORE BotVersion.init()",
-          );
-        }
-      }
-
-      // Next.js scan
-      // Next.js scan — auto detect all possible structures
-      if (!app) {
-        const fs = require("fs");
-        const path = require("path");
-        const cwd = process.cwd();
-
-        const possibleAppDirs = [
-          path.join(cwd, "app"),
-          path.join(cwd, "src", "app"),
-        ];
-
-        const possiblePagesDirs = [
-          path.join(cwd, "pages"),
-          path.join(cwd, "src", "pages"),
-        ];
-
-        for (const dir of possibleAppDirs) {
-          if (fs.existsSync(dir)) {
-            console.log("[BotVersion SDK] Scanning App Router routes at:", dir);
-            const routes = scanner.scanNextJsAppRoutes(dir);
-            endpoints = endpoints.concat(routes);
-            console.log(
-              "[BotVersion SDK] Found",
-              routes.length,
-              "App Router routes",
-            );
-          }
-        }
-
-        for (const dir of possiblePagesDirs) {
-          if (fs.existsSync(dir)) {
-            console.log(
-              "[BotVersion SDK] Scanning Pages Router routes at:",
-              dir,
-            );
-            const routes = scanner.scanNextJsRoutes(dir);
-            endpoints = endpoints.concat(routes);
-            console.log(
-              "[BotVersion SDK] Found",
-              routes.length,
-              "Pages Router routes",
-            );
-          }
-        }
-      }
+      // Run backend scanner
+      var endpoints = runBackendScanner(detectedBackend, app, options, cwd);
 
-      // Neither Express nor pagesDir
-      // Neither Express nor Next.js routes found
-      if (!app && endpoints.length === 0) {
-        console.error(
-          "[BotVersion SDK] ❌ No routes found. Make sure your app/api or pages/api folder exists.",
-        );
-        return;
-      }
-
-      // Send to platform
+      // Send endpoints to platform
       if (endpoints.length > 0) {
-        console.log(
-          "[BotVersion SDK] Sending",
-          endpoints.length,
-          "endpoints to platform...",
-        );
-        self._client
-          .registerEndpoints(endpoints)
-          .then(function () {
-            console.log(
-              "[BotVersion SDK] ✅ Endpoints queued —",
-              endpoints.length,
-              "endpoints will be sent shortly",
-            );
-          })
-          .catch(function (err) {
-            console.error(
-              "[BotVersion SDK] ❌ Failed to register endpoints:",
-              err.message,
-            );
-          });
+        self._client.registerEndpoints(endpoints);
       }
 
-      var routePatterns = scanner.scanFrontendRoutes(
-        options.cwd || process.cwd(),
-      );
+      // Run frontend route scanner
+      var routePatterns = scanner.scanFrontendRoutes(cwd);
+
       if (routePatterns.length > 0) {
-        console.log(
-          "[BotVersion SDK] Found",
-          routePatterns.length,
-          "frontend route patterns",
-        );
-        self._client
-          .registerRoutePatterns(routePatterns)
-          .then(function () {
-            console.log("[BotVersion SDK] ✅ Route patterns registered");
-          })
-          .catch(function (err) {
-            console.error(
-              "[BotVersion SDK] ❌ Failed to register route patterns:",
-              err.message,
-            );
-          });
+        self._client.registerRoutePatterns(routePatterns).catch(function () {
+          // silently ignore — non-critical
+        });
       }
-
-      self._client.connect();
-      console.log("[BotVersion SDK] ✅ Initialization complete");
-    }, 500);
+    }, 3000);
   },
 
   getEndpoints: function () {
@@ -270,36 +377,3 @@ module.exports.default = BotVersion;
 module.exports.init = BotVersion.init;
 module.exports.getEndpoints = BotVersion.getEndpoints;
 module.exports.registerEndpoint = BotVersion.registerEndpoint;
-
-// ── Framework detection ──────────────────────────────────────────────────────
-function detectFramework(app) {
-  if (!app) return { supported: false, name: "unknown (no app passed)" };
-
-  var isExpress =
-    typeof app.use === "function" &&
-    typeof app.get === "function" &&
-    typeof app.post === "function" &&
-    (app._router !== undefined ||
-      app.stack !== undefined ||
-      app.lazyrouter !== undefined);
-
-  if (isExpress) return { supported: true, name: "Express" };
-
-  if (typeof app.addHook === "function" && typeof app.route === "function") {
-    return { supported: false, name: "Fastify" };
-  }
-
-  if (
-    typeof app.use === "function" &&
-    app.context !== undefined &&
-    typeof app.get !== "function"
-  ) {
-    return { supported: false, name: "Koa" };
-  }
-
-  if (typeof app.route === "function" && typeof app.start === "function") {
-    return { supported: false, name: "Hapi" };
-  }
-
-  return { supported: false, name: "unknown" };
-}