reportli 1.0.1 → 1.0.3

package/dist/index.mjs

@@ -8,14 +8,64 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 
 // src/index.ts
 var ENDPOINT = "https://fahikyfmgdyzejdfftox.supabase.co/functions/v1/rapid-processor";
-var isBrowser = typeof window !== "undefined";
-var isNode = typeof process !== "undefined" && !!process.versions?.node;
-var _apiKey = "";
-function getEnvironment() {
-  return isBrowser ? "browser" : "server";
+var initialized = false;
+var _config;
+var queue = [];
+var flushTimer = null;
+var isFlushing = false;
+function scheduleFlush() {
+  if (flushTimer)
+    return;
+  flushTimer = setTimeout(() => {
+    flushTimer = null;
+    flush();
+  }, 2e3);
+}
+async function flush() {
+  if (isFlushing || queue.length === 0)
+    return;
+  isFlushing = true;
+  const batch = queue.splice(0, 10);
+  for (const payload of batch) {
+    await sendNow(payload);
+  }
+  isFlushing = false;
+  if (queue.length > 0)
+    flush();
+}
+async function sendNow(payload, attempts = 3) {
+  for (let i = 0; i < attempts; i++) {
+    try {
+      const res = await fetch(ENDPOINT, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": _config?.apiKey ?? ""
+        },
+        body: JSON.stringify(payload)
+      });
+      if (res.ok)
+        return;
+    } catch {
+    }
+    await sleep(1e3 * (i + 1));
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function enqueue(payload) {
+  if (queue.length >= 100)
+    return;
+  queue.push(payload);
+  scheduleFlush();
+}
+function sendImmediate(payload) {
+  sendNow(payload).catch(() => {
+  });
 }
 function getUrl() {
-  if (isBrowser)
+  if (typeof window !== "undefined")
     return window.location.href;
   try {
     return __require("os").hostname();
@@ -24,10 +74,13 @@ function getUrl() {
   }
 }
 function getBrowser() {
-  if (isBrowser)
+  if (typeof navigator !== "undefined")
     return navigator.userAgent;
   return `Node.js ${typeof process !== "undefined" ? process.version : "unknown"}`;
 }
+function getEnvironment() {
+  return _config?.environment ?? (typeof window !== "undefined" ? "browser" : "server");
+}
 function parseStack(stack) {
   if (!stack)
     return { file: "unknown", line: 0, column: 0 };
@@ -44,140 +97,79 @@ function getErrorCode(error) {
 function classifyError(error, context) {
   const msg = String(error?.message || error || "").toLowerCase();
   const name = String(error?.name || "").toLowerCase();
-  if (name.includes("quotaexceeded") || msg.includes("quota exceeded") || msg.includes("localstorage") || msg.includes("indexeddb"))
-    return { errorType: "localStorage quota exceeded", severity: "medium" };
+  if (msg.includes("stripe") || msg.includes("payment") || msg.includes("card declined") || msg.includes("checkout") || msg.includes("refund"))
+    return { category: "Payment Error", severity: "critical" };
+  if (msg.includes("jwt") || msg.includes("token expired") || msg.includes("unauthorized") || msg.includes("session") || msg.includes("oauth") || msg.includes("login failed"))
+    return { category: "Auth Error", severity: "high" };
+  if (msg.includes("supabase") || msg.includes("database") || msg.includes("query") || msg.includes("connection lost") || msg.includes("transaction") || msg.includes("duplicate key") || msg.includes("foreign key"))
+    return { category: "Database Error", severity: "critical" };
   if (msg.includes("hydration") || msg.includes("does not match server"))
-    return { errorType: "React hydration error", severity: "high" };
-  if (msg.includes("invalid hook call") || msg.includes("rules of hooks"))
-    return { errorType: "Invalid hook call error", severity: "critical" };
-  if (msg.includes("failed prop type") || msg.includes("invalid prop"))
-    return { errorType: "Props type error", severity: "low" };
-  if (msg.includes("render") || msg.includes("react error boundary"))
-    return { errorType: "Component render error", severity: "critical" };
-  if (msg.includes("route not found") || msg.includes("404 route"))
-    return { errorType: "Route not found error", severity: "medium" };
-  if (msg.includes("failed to fetch dynamically imported") || msg.includes("dynamic import"))
-    return { errorType: "Dynamic import error", severity: "high" };
-  if (msg.includes("suspense"))
-    return { errorType: "Suspense boundary error", severity: "medium" };
-  if (name === "typeerror" || msg.startsWith("typeerror"))
-    return { errorType: "TypeError", severity: "high" };
-  if (name === "referenceerror")
-    return { errorType: "ReferenceError", severity: "critical" };
-  if (name === "rangeerror" || msg.includes("maximum call stack"))
-    return { errorType: "Stack overflow error", severity: "critical" };
-  if (name === "syntaxerror")
-    return { errorType: "SyntaxError", severity: "high" };
-  if (msg.includes("stripe") && (msg.includes("init") || msg.includes("key")))
-    return { errorType: "Stripe initialization error", severity: "critical" };
-  if (msg.includes("payment") || msg.includes("card declined"))
-    return { errorType: "Payment processing error", severity: "critical" };
-  if (msg.includes("checkout session"))
-    return { errorType: "Checkout session error", severity: "high" };
-  if (msg.includes("refund failed"))
-    return { errorType: "Refund failed error", severity: "high" };
-  if (msg.includes("supabase") || msg.includes("postgresterror"))
-    return { errorType: "Supabase query error", severity: "critical" };
-  if (msg.includes("unique constraint") || msg.includes("duplicate key"))
-    return { errorType: "Unique constraint error", severity: "high" };
-  if (msg.includes("foreign key"))
-    return { errorType: "Foreign key error", severity: "high" };
-  if (msg.includes("transaction failed") || msg.includes("rollback"))
-    return { errorType: "Transaction failed error", severity: "critical" };
-  if (msg.includes("connection lost") || msg.includes("econnrefused"))
-    return { errorType: "Connection lost error", severity: "critical" };
-  if (msg.includes("query timeout"))
-    return { errorType: "Query timeout error", severity: "high" };
-  if (msg.includes("jwt expired") || msg.includes("token expired"))
-    return { errorType: "JWT expired error", severity: "high" };
-  if (msg.includes("jwt") && msg.includes("invalid"))
-    return { errorType: "JWT verification error", severity: "high" };
-  if (msg.includes("firebase admin"))
-    return { errorType: "Firebase admin error", severity: "critical" };
-  if (msg.includes("unauthorized") || msg.includes("permission denied"))
-    return { errorType: "Unauthorized access error", severity: "high" };
-  if (msg.includes("login failed") || msg.includes("invalid credentials"))
-    return { errorType: "Login failed error", severity: "medium" };
-  if (msg.includes("session ended") || msg.includes("session expired"))
-    return { errorType: "Session ended error", severity: "medium" };
-  if (msg.includes("oauth"))
-    return { errorType: "OAuth callback error", severity: "high" };
-  if (msg.includes("cron job") || msg.includes("cron failed"))
-    return { errorType: "Cron job failed", severity: "high" };
-  if (msg.includes("queue processing") || msg.includes("bullmq"))
-    return { errorType: "Queue processing error", severity: "high" };
-  if (msg.includes("webhook"))
-    return { errorType: "Webhook delivery failed", severity: "high" };
-  if (msg.includes("retry limit"))
-    return { errorType: "Retry limit exceeded", severity: "high" };
-  if (msg.includes("out of memory") || msg.includes("heap limit"))
-    return { errorType: "Out of memory error", severity: "critical" };
-  if (msg.includes("cannot find module"))
-    return { errorType: "Module not found error", severity: "critical" };
-  if (msg.includes("email") || msg.includes("smtp") || msg.includes("sendgrid") || msg.includes("nodemailer"))
-    return { errorType: "Email sending failed", severity: "high" };
-  if (msg.includes("onesignal") || msg.includes("push notification"))
-    return { errorType: "OneSignal API error", severity: "high" };
-  if (msg.includes("file upload") || msg.includes("upload failed"))
-    return { errorType: "File upload failed", severity: "high" };
-  if (msg.includes("file size exceeded") || msg.includes("payload too large"))
-    return { errorType: "File size exceeded", severity: "medium" };
-  if (msg.includes("invalid file type") || msg.includes("mime type"))
-    return { errorType: "Invalid file type", severity: "medium" };
+    return { category: "Hydration Error", severity: "high" };
+  if (msg.includes("invalid hook") || msg.includes("rules of hooks"))
+    return { category: "Hook Error", severity: "critical" };
+  if (msg.includes("render") || msg.includes("error boundary"))
+    return { category: "Render Error", severity: "critical" };
+  if (msg.includes("dynamic import") || msg.includes("failed to fetch dynamically"))
+    return { category: "Import Error", severity: "high" };
   if (msg.includes("cors") || msg.includes("cross-origin"))
-    return { errorType: "CORS error", severity: "high" };
-  if (msg.includes("fetch failed") || msg.includes("failed to fetch"))
-    return { errorType: "Fetch failed error", severity: "high" };
+    return { category: "CORS Error", severity: "high" };
+  if (msg.includes("fetch failed") || msg.includes("failed to fetch") || name === "fetcherror")
+    return { category: "Network Error", severity: "high" };
   if (msg.includes("timeout") || msg.includes("timed out") || msg.includes("etimedout"))
-    return { errorType: "Request timeout error", severity: "medium" };
+    return { category: "Timeout Error", severity: "medium" };
   if (msg.includes("websocket"))
-    return { errorType: "WebSocket connection error", severity: "high" };
+    return { category: "WebSocket Error", severity: "high" };
+  if (msg.includes("http 401") || msg.includes("xhr 401"))
+    return { category: "Auth Error", severity: "high" };
+  if (msg.includes("http 403") || msg.includes("xhr 403"))
+    return { category: "Auth Error", severity: "high" };
+  if (msg.includes("http 404") || msg.includes("xhr 404"))
+    return { category: "Not Found Error", severity: "medium" };
+  if (msg.includes("http 500") || msg.includes("xhr 500"))
+    return { category: "Server Error", severity: "critical" };
+  if (msg.includes("http 503") || msg.includes("xhr 503"))
+    return { category: "Server Error", severity: "critical" };
+  if (msg.includes("maximum call stack") || msg.includes("out of memory") || msg.includes("heap limit"))
+    return { category: "Memory Error", severity: "critical" };
+  if (msg.includes("cannot find module") || msg.includes("module not found"))
+    return { category: "Module Error", severity: "critical" };
+  if (msg.includes("econnrefused") || msg.includes("connection refused"))
+    return { category: "Connection Error", severity: "critical" };
+  if (msg.includes("email") || msg.includes("smtp") || msg.includes("sendgrid"))
+    return { category: "Email Error", severity: "high" };
+  if (msg.includes("cron") || msg.includes("webhook") || msg.includes("queue"))
+    return { category: "Job Error", severity: "high" };
+  if (msg.includes("upload") || msg.includes("file size") || msg.includes("invalid file"))
+    return { category: "File Error", severity: "medium" };
+  if (msg.includes("quota exceeded") || msg.includes("localstorage") || msg.includes("indexeddb"))
+    return { category: "Storage Error", severity: "medium" };
+  if (name === "typeerror")
+    return { category: "TypeError", severity: "high" };
+  if (name === "referenceerror")
+    return { category: "ReferenceError", severity: "critical" };
+  if (name === "rangeerror")
+    return { category: "RangeError", severity: "high" };
+  if (name === "syntaxerror")
+    return { category: "SyntaxError", severity: "high" };
   if (context === "unhandledrejection")
-    return { errorType: "Unhandled promise rejection", severity: "medium" };
-  if (context === "uncaughtexception")
-    return { errorType: "Uncaught exception", severity: "high" };
+    return { category: "Promise Error", severity: "medium" };
   if (context === "express")
-    return { errorType: "Route handler error", severity: "high" };
-  return { errorType: "Uncaught exception", severity: "medium" };
-}
-function normalizeError(err) {
-  if (err instanceof Error)
-    return { name: err.name, message: err.message, stack: err.stack };
-  if (typeof err === "string")
-    return { name: "Error", message: err, stack: new Error(err).stack };
-  if (err && typeof err === "object")
-    return {
-      name: err.name || err.code || "Error",
-      message: err.message || err.reason || JSON.stringify(err),
-      stack: err.stack || new Error(err.message).stack
-    };
-  return { name: "Error", message: "Unknown error", stack: new Error().stack };
-}
-async function send(payload) {
-  try {
-    if (payload.message?.includes("rapid-processor"))
-      return;
-    await fetch(ENDPOINT, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "x-api-key": _apiKey
-      },
-      body: JSON.stringify(payload)
-    });
-  } catch {
-  }
+    return { category: "Server Error", severity: "high" };
+  if (context === "resource")
+    return { category: "Resource Error", severity: "low" };
+  return { category: "Unknown Error", severity: "medium" };
 }
 function buildErrorPayload(error, context) {
-  const normalized = normalizeError(error);
-  const { file, line, column } = parseStack(normalized.stack);
-  const { errorType, severity } = classifyError(normalized, context);
+  const message = error?.message || String(error) || "Unknown error";
+  const stack = error?.stack || "";
+  const { file, line, column } = parseStack(stack);
+  const { category, severity } = classifyError(error, context);
   return {
     type: "ERROR",
-    apiKey: _apiKey,
-    message: normalized.message,
+    apiKey: _config?.apiKey,
+    message,
     code: getErrorCode(error),
-    stack: normalized.stack || "",
+    stack,
     file,
     line,
     column,
@@ -185,166 +177,157 @@ function buildErrorPayload(error, context) {
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     environment: getEnvironment(),
     browser: getBrowser(),
-    error_category: errorType,
+    error_category: category,
     severity,
-    status: "open"
+    status: "open",
+    context: context || "auto"
   };
 }
 function activateBrowserListeners() {
   window.addEventListener("error", (event) => {
-    if (event.filename?.includes("rapid-processor"))
-      return;
     const target = event.target;
-    if (target && target.tagName) {
-      const tag = target.tagName;
-      const src = target.src || target.href || "";
-      if (["IMG", "SCRIPT", "LINK", "VIDEO", "AUDIO", "SOURCE"].includes(tag)) {
-        send(buildErrorPayload({
-          name: "ResourceError",
-          message: `${tag} failed to load: ${src}`,
-          stack: `at ${window.location.href}`
-        }));
-        return;
-      }
+    if (target && target.tagName && ["IMG", "SCRIPT", "LINK", "VIDEO", "AUDIO"].includes(target.tagName)) {
+      const src = target.src || target.href || "unknown";
+      enqueue(buildErrorPayload({ name: "ResourceError", message: `${target.tagName} failed to load: ${src}`, stack: "" }, "resource"));
+      return;
     }
     const err = event.error || {
       name: "Error",
       message: event.message,
-      stack: `${event.message} at ${event.filename}:${event.lineno}:${event.colno}`
+      stack: `at ${event.filename}:${event.lineno}:${event.colno}`
     };
-    send(buildErrorPayload(err));
+    enqueue(buildErrorPayload(err, "window"));
   }, true);
   window.addEventListener("unhandledrejection", (event) => {
-    send(buildErrorPayload(event.reason || { message: "Unhandled Promise Rejection" }, "unhandledrejection"));
+    const err = event.reason instanceof Error ? event.reason : { name: "UnhandledRejection", message: String(event.reason || "Unhandled Promise Rejection"), stack: "" };
+    enqueue(buildErrorPayload(err, "unhandledrejection"));
   });
   const originalFetch = window.fetch;
-  window.fetch = async function(input, init) {
-    const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
-    if (url.includes("rapid-processor") || url.includes("supabase.co/functions")) {
-      return originalFetch.apply(this, arguments);
-    }
+  window.fetch = async function(...args) {
+    const url = typeof args[0] === "string" ? args[0] : args[0] instanceof URL ? args[0].toString() : args[0]?.url ?? "";
+    if (url.includes("rapid-processor"))
+      return originalFetch(...args);
     try {
-      const response = await originalFetch.apply(this, arguments);
+      const response = await originalFetch(...args);
       if (!response.ok) {
-        send(buildErrorPayload({
-          name: `API ${response.status} Error`,
-          message: `HTTP ${response.status}: ${init?.method || "GET"} ${url}`,
-          stack: `${init?.method || "GET"} ${url} \u2192 ${response.status} ${response.statusText}`,
+        enqueue(buildErrorPayload({
+          name: `HTTP_${response.status}`,
+          message: `HTTP ${response.status}: ${args[1]?.method || "GET"} ${url}`,
+          stack: `${args[1]?.method || "GET"} ${url} \u2192 ${response.status} ${response.statusText}`,
           status: response.status
-        }));
+        }, "fetch"));
       }
       return response;
     } catch (err) {
-      send(buildErrorPayload({
+      enqueue(buildErrorPayload({
         name: "FetchError",
-        message: `Fetch failed: ${init?.method || "GET"} ${url} \u2014 ${err.message}`,
+        message: `Fetch failed: ${args[1]?.method || "GET"} ${url} \u2014 ${err.message}`,
         stack: err.stack
-      }));
+      }, "fetch"));
       throw err;
     }
   };
   const originalOpen = XMLHttpRequest.prototype.open;
   const originalSend = XMLHttpRequest.prototype.send;
-  XMLHttpRequest.prototype.open = function(method, url) {
+  XMLHttpRequest.prototype.open = function(method, url, ...rest) {
     this._r_method = method;
     this._r_url = url;
-    return originalOpen.apply(this, arguments);
+    return originalOpen.call(this, method, url, ...rest);
   };
-  XMLHttpRequest.prototype.send = function() {
-    this.addEventListener("loadend", () => {
-      const url = this._r_url || "";
-      const method = this._r_method || "GET";
-      if (url.includes("rapid-processor"))
-        return;
-      if (this.status >= 400 || this.status === 0) {
-        send(buildErrorPayload({
-          name: `XHR ${this.status} Error`,
-          message: `XHR ${this.status}: ${method} ${url}`,
-          stack: `${method} ${url} \u2192 ${this.status} ${this.statusText}`,
-          status: this.status
-        }));
-      }
-    });
-    return originalSend.apply(this, arguments);
+  XMLHttpRequest.prototype.send = function(...args) {
+    const url = this._r_url || "";
+    const method = this._r_method || "GET";
+    if (!url.includes("rapid-processor")) {
+      this.addEventListener("loadend", () => {
+        if (this.status >= 400 || this.status === 0) {
+          enqueue(buildErrorPayload({
+            name: `XHR_${this.status}`,
+            message: `XHR ${this.status}: ${method} ${url}`,
+            stack: `${method} ${url} \u2192 ${this.status} ${this.statusText}`,
+            status: this.status
+          }, "xhr"));
+        }
+      });
+    }
+    return originalSend.apply(this, args);
   };
   window.addEventListener("beforeunload", () => {
     try {
-      navigator.sendBeacon(ENDPOINT, JSON.stringify({
-        type: "SDK_DISCONNECTED",
-        apiKey: _apiKey,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        environment: "browser",
-        url: getUrl()
-      }));
+      navigator.sendBeacon(
+        ENDPOINT,
+        JSON.stringify({
+          type: "SDK_DISCONNECTED",
+          apiKey: _config?.apiKey,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          environment: getEnvironment(),
+          url: getUrl()
+        })
+      );
     } catch {
     }
   });
 }
 function activateServerListeners() {
   process.on("uncaughtException", (error) => {
-    send(buildErrorPayload(error, "uncaughtexception"));
+    enqueue(buildErrorPayload(error, "uncaughtException"));
+    flush();
   });
   process.on("unhandledRejection", (reason) => {
-    send(buildErrorPayload(
+    enqueue(buildErrorPayload(
       reason instanceof Error ? reason : { name: "UnhandledRejection", message: String(reason), stack: "" },
       "unhandledrejection"
     ));
   });
-  const shutdown = async () => {
-    await send({
+  const shutdown = async (signal) => {
+    await sendNow({
       type: "SDK_DISCONNECTED",
-      apiKey: _apiKey,
+      apiKey: _config?.apiKey,
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      environment: "server",
-      url: getUrl()
+      environment: getEnvironment(),
+      url: getUrl(),
+      signal
     });
     process.exit(0);
   };
-  process.on("SIGTERM", shutdown);
-  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGINT", () => shutdown("SIGINT"));
 }
 var Reportli = {
-  init({ apiKey }) {
-    if (!apiKey || _apiKey)
+  init(cfg) {
+    if (initialized)
       return;
-    _apiKey = apiKey;
-    if (isBrowser && typeof localStorage !== "undefined") {
-      const key = `reportli_init_${apiKey}`;
-      if (!localStorage.getItem(key)) {
-        localStorage.setItem(key, "true");
-        send({
-          type: "SDK_INITIALIZED",
-          apiKey: _apiKey,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          environment: getEnvironment(),
-          url: getUrl(),
-          browser: getBrowser()
-        });
-      }
-    } else {
-      send({
-        type: "SDK_INITIALIZED",
-        apiKey: _apiKey,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        environment: getEnvironment(),
-        url: getUrl(),
-        browser: getBrowser()
-      });
-    }
-    if (isBrowser) {
+    if (!cfg?.apiKey)
+      return;
+    _config = cfg;
+    initialized = true;
+    sendImmediate({
+      type: "SDK_INITIALIZED",
+      apiKey: cfg.apiKey,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      environment: getEnvironment(),
+      url: getUrl(),
+      browser: getBrowser()
+    });
+    if (typeof window !== "undefined") {
       activateBrowserListeners();
-    } else if (isNode) {
+    } else if (typeof process !== "undefined" && process.versions?.node) {
       activateServerListeners();
     }
   },
   capture(error) {
-    if (!_apiKey)
+    if (!initialized)
+      return;
+    const err = error instanceof Error ? error : { name: "ManualCapture", message: String(error), stack: new Error().stack };
+    enqueue(buildErrorPayload(err, "manual"));
+  },
+  captureMessage(message) {
+    if (!initialized)
       return;
-    send(buildErrorPayload(error, "manual"));
+    enqueue(buildErrorPayload({ name: "Message", message, stack: "" }, "manual"));
   },
   errorHandler() {
     return function(err, _req, _res, next) {
-      send(buildErrorPayload(err, "express"));
+      enqueue(buildErrorPayload(err, "express"));
       next(err);
     };
   }