jahiz-tracker 1.0.0

package/dist/index.cjs

@@ -0,0 +1,359 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  JahizErrorBoundary: () => JahizErrorBoundary_default,
+  JahizTracker: () => JahizTracker,
+  createJahizTracker: () => createJahizTracker,
+  getJahizTracker: () => getJahizTracker,
+  useJahizTracker: () => useJahizTracker
+});
+module.exports = __toCommonJS(index_exports);
+
+// jahiz-tracker.ts
+var JahizTracker = class {
+  constructor(config) {
+    this.user = {};
+    this.initialized = false;
+    this.config = {
+      captureGlobal: true,
+      collectDeviceInfo: true,
+      ...config
+    };
+  }
+  /** Initialize the tracker. Call once at app startup. */
+  init() {
+    if (this.initialized) return;
+    this.initialized = true;
+    if (this.config.captureGlobal && typeof window !== "undefined") {
+      window.addEventListener("error", (event) => {
+        this.captureError(event.error ?? event.message, {
+          metadata: {
+            source: "window.onerror",
+            filename: event.filename,
+            lineno: event.lineno,
+            colno: event.colno
+          }
+        });
+      });
+      window.addEventListener("unhandledrejection", (event) => {
+        const error = event.reason instanceof Error ? event.reason : new Error(String(event.reason));
+        this.captureError(error, {
+          metadata: { source: "unhandledrejection" }
+        });
+      });
+    }
+  }
+  /** Set the current user context. Attached to all subsequent reports. */
+  setUser(user) {
+    this.user = user;
+  }
+  /** Clear user context (e.g. on logout). */
+  clearUser() {
+    this.user = {};
+  }
+  /** Capture an Error object or string message. */
+  async captureError(error, options = {}) {
+    const isError = error instanceof Error;
+    const message = isError ? error.message : String(error);
+    const stack = isError ? error.stack : void 0;
+    const parsed = stack ? this.parseStack(stack) : {};
+    const payload = this.buildPayload({
+      error_message: message,
+      severity: options.severity ?? "error",
+      error_type: isError ? error.name : void 0,
+      error_code: options.errorCode,
+      stacktrace: stack,
+      file_name: parsed.fileName,
+      line_number: parsed.lineNumber,
+      function_name: parsed.functionName,
+      component: options.component,
+      context: options.context,
+      user: { ...this.user, ...options.user },
+      tags: { ...this.config.defaultTags, ...options.tags },
+      metadata: options.metadata,
+      fingerprint: this.generateFingerprint(
+        isError ? error.name : "Error",
+        message,
+        parsed.fileName
+      )
+    });
+    return this.send(payload);
+  }
+  /** Report a custom error message (not from a thrown Error). */
+  async captureMessage(message, options = {}) {
+    const payload = this.buildPayload({
+      error_message: message,
+      severity: options.severity ?? "info",
+      error_code: options.errorCode,
+      component: options.component,
+      context: options.context,
+      user: { ...this.user, ...options.user },
+      tags: { ...this.config.defaultTags, ...options.tags },
+      metadata: options.metadata
+    });
+    return this.send(payload);
+  }
+  /** Wrap an async function so errors are automatically captured. */
+  wrap(fn, options = {}) {
+    const tracker = this;
+    return function(...args) {
+      try {
+        const result = fn.apply(this, args);
+        if (result instanceof Promise) {
+          return result.catch((err) => {
+            tracker.captureError(err, options);
+            throw err;
+          });
+        }
+        return result;
+      } catch (err) {
+        tracker.captureError(err, options);
+        throw err;
+      }
+    };
+  }
+  // ─── Internal ────────────────────────────────────────────────────
+  buildPayload(partial) {
+    const payload = {
+      error_message: partial.error_message ?? "Unknown error",
+      severity: partial.severity ?? "error",
+      ...partial,
+      app_name: partial.app_name ?? this.config.appName,
+      app_version: partial.app_version ?? this.config.appVersion,
+      environment: partial.environment ?? this.config.environment,
+      service_name: partial.service_name ?? this.config.serviceName,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (this.config.collectDeviceInfo && typeof window !== "undefined") {
+      payload.device = this.collectBrowserInfo();
+    }
+    return payload;
+  }
+  async send(payload) {
+    if (this.config.beforeSend) {
+      const result = this.config.beforeSend(payload);
+      if (result === false) return null;
+      payload = result;
+    }
+    try {
+      const url = this.config.webhookUrl.replace(/\/$/, "");
+      const response = await fetch(`${url}/webhook/error`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-Webhook-Secret": this.config.webhookSecret
+        },
+        body: JSON.stringify(payload)
+      });
+      if (!response.ok) {
+        console.error(
+          `[JahizTracker] Webhook returned ${response.status}:`,
+          await response.text()
+        );
+        return null;
+      }
+      return await response.json();
+    } catch (err) {
+      console.error("[JahizTracker] Failed to send error report:", err);
+      return null;
+    }
+  }
+  parseStack(stack) {
+    const lines = stack.split("\n").filter((l) => l.trim());
+    const frameLine = lines[1] ?? lines[0] ?? "";
+    const chromeMatch = frameLine.match(
+      /at\s+(.+?)\s+\((.+?):(\d+):\d+\)/
+    );
+    if (chromeMatch) {
+      return {
+        functionName: chromeMatch[1],
+        fileName: chromeMatch[2],
+        lineNumber: parseInt(chromeMatch[3], 10)
+      };
+    }
+    const firefoxMatch = frameLine.match(/(.+?)@(.+?):(\d+):\d+/);
+    if (firefoxMatch) {
+      return {
+        functionName: firefoxMatch[1],
+        fileName: firefoxMatch[2],
+        lineNumber: parseInt(firefoxMatch[3], 10)
+      };
+    }
+    return {};
+  }
+  collectBrowserInfo() {
+    const nav = typeof navigator !== "undefined" ? navigator : null;
+    if (!nav) return {};
+    return {
+      os: this.getOS(),
+      osVersion: nav.userAgent,
+      architecture: nav.userAgentData?.platform ?? nav.platform
+    };
+  }
+  getOS() {
+    const ua = navigator.userAgent;
+    if (ua.includes("Win")) return "Windows";
+    if (ua.includes("Mac")) return "macOS";
+    if (ua.includes("Linux")) return "Linux";
+    if (ua.includes("Android")) return "Android";
+    if (/iPhone|iPad|iPod/.test(ua)) return "iOS";
+    return "Unknown";
+  }
+  generateFingerprint(type, message, fileName) {
+    const raw = `${type}:${message}:${fileName ?? ""}`;
+    let hash = 0;
+    for (let i = 0; i < raw.length; i++) {
+      const char = raw.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash |= 0;
+    }
+    return Math.abs(hash).toString(16);
+  }
+};
+var instance = null;
+function createJahizTracker(config) {
+  instance = new JahizTracker(config);
+  instance.init();
+  return instance;
+}
+function getJahizTracker() {
+  if (!instance) {
+    throw new Error(
+      "[JahizTracker] Not initialized. Call createJahizTracker() first."
+    );
+  }
+  return instance;
+}
+
+// react/JahizErrorBoundary.tsx
+var import_react = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var JahizErrorBoundary = class extends import_react.Component {
+  constructor(props) {
+    super(props);
+    this.reset = () => {
+      this.setState({ hasError: false, error: null });
+    };
+    this.state = { hasError: false, error: null };
+  }
+  static getDerivedStateFromError(error) {
+    return { hasError: true, error };
+  }
+  componentDidCatch(error, errorInfo) {
+    const tracker = getJahizTracker();
+    tracker.captureError(error, {
+      severity: "critical",
+      component: this.props.component,
+      ...this.props.reportOptions,
+      metadata: {
+        ...this.props.reportOptions?.metadata,
+        componentStack: errorInfo.componentStack ?? void 0,
+        source: "JahizErrorBoundary"
+      }
+    });
+    this.props.onError?.(error, errorInfo);
+  }
+  render() {
+    if (this.state.hasError && this.state.error) {
+      if (typeof this.props.fallback === "function") {
+        return this.props.fallback(this.state.error, this.reset);
+      }
+      if (this.props.fallback) {
+        return this.props.fallback;
+      }
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+        "div",
+        {
+          style: {
+            padding: "2rem",
+            textAlign: "center",
+            fontFamily: "system-ui, sans-serif"
+          },
+          children: [
+            /* @__PURE__ */ (0, import_jsx_runtime.jsx)("h2", { style: { color: "#dc2626" }, children: "Something went wrong" }),
+            /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { style: { color: "#6b7280" }, children: "The error has been automatically reported." }),
+            /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+              "button",
+              {
+                onClick: this.reset,
+                style: {
+                  marginTop: "1rem",
+                  padding: "0.5rem 1.5rem",
+                  borderRadius: "0.375rem",
+                  border: "1px solid #d1d5db",
+                  background: "#fff",
+                  cursor: "pointer",
+                  fontSize: "0.875rem"
+                },
+                children: "Try Again"
+              }
+            )
+          ]
+        }
+      );
+    }
+    return this.props.children;
+  }
+};
+var JahizErrorBoundary_default = JahizErrorBoundary;
+
+// react/useJahizTracker.ts
+var import_react2 = require("react");
+function useJahizTracker(component) {
+  const trackerRef = (0, import_react2.useRef)(getJahizTracker());
+  const captureError = (0, import_react2.useCallback)(
+    async (error, options = {}) => {
+      return trackerRef.current.captureError(error, {
+        component,
+        ...options
+      });
+    },
+    [component]
+  );
+  const captureMessage = (0, import_react2.useCallback)(
+    async (message, options = {}) => {
+      return trackerRef.current.captureMessage(message, {
+        component,
+        ...options
+      });
+    },
+    [component]
+  );
+  const setUser = (0, import_react2.useCallback)(
+    (user) => {
+      trackerRef.current.setUser(user);
+    },
+    []
+  );
+  const clearUser = (0, import_react2.useCallback)(() => {
+    trackerRef.current.clearUser();
+  }, []);
+  return { captureError, captureMessage, setUser, clearUser };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JahizErrorBoundary,
+  JahizTracker,
+  createJahizTracker,
+  getJahizTracker,
+  useJahizTracker
+});

package/dist/index.d.cts

@@ -0,0 +1,166 @@
+import { Component, ReactNode, ErrorInfo } from 'react';
+
+/**
+ * Jahiz Error Tracker - Core Client
+ *
+ * Lightweight client for sending error reports to the Jahiz webhook.
+ * Framework-agnostic. Works in any JS/TS environment (browser, Node, Deno).
+ */
+type Severity = "critical" | "error" | "warning" | "info";
+interface JahizConfig {
+    webhookUrl: string;
+    webhookSecret: string;
+    appName?: string;
+    appVersion?: string;
+    environment?: string;
+    serviceName?: string;
+    /** Automatically capture unhandled errors and promise rejections. Default: true */
+    captureGlobal?: boolean;
+    /** Collect browser/device info automatically. Default: true */
+    collectDeviceInfo?: boolean;
+    /** Custom tags applied to every error report */
+    defaultTags?: Record<string, string>;
+    /** Callback before sending — return false to skip */
+    beforeSend?: (payload: ErrorPayload) => ErrorPayload | false;
+}
+interface UserInfo {
+    userId?: string;
+    username?: string;
+    email?: string;
+    sessionId?: string;
+    ipAddress?: string;
+}
+interface ErrorContext {
+    requestUrl?: string;
+    requestMethod?: string;
+    responseStatus?: number;
+    queryParams?: Record<string, string>;
+}
+interface DeviceInfo {
+    hostname?: string;
+    os?: string;
+    osVersion?: string;
+    architecture?: string;
+    ipAddress?: string;
+}
+interface ErrorPayload {
+    error_message: string;
+    severity: Severity;
+    error_type?: string;
+    error_code?: string;
+    stacktrace?: string;
+    file_name?: string;
+    line_number?: number;
+    function_name?: string;
+    app_name?: string;
+    app_version?: string;
+    environment?: string;
+    service_name?: string;
+    component?: string;
+    context?: Partial<ErrorContext>;
+    user?: Partial<UserInfo>;
+    device?: Partial<DeviceInfo>;
+    tags?: Record<string, string>;
+    metadata?: Record<string, unknown>;
+    fingerprint?: string;
+    timestamp?: string;
+}
+interface WebhookResponse {
+    success: boolean;
+    message: string;
+    error_id?: string;
+    timestamp: string;
+}
+interface ReportOptions {
+    severity?: Severity;
+    component?: string;
+    errorCode?: string;
+    context?: Partial<ErrorContext>;
+    user?: Partial<UserInfo>;
+    tags?: Record<string, string>;
+    metadata?: Record<string, unknown>;
+}
+declare class JahizTracker {
+    private config;
+    private user;
+    private initialized;
+    constructor(config: JahizConfig);
+    /** Initialize the tracker. Call once at app startup. */
+    init(): void;
+    /** Set the current user context. Attached to all subsequent reports. */
+    setUser(user: Partial<UserInfo>): void;
+    /** Clear user context (e.g. on logout). */
+    clearUser(): void;
+    /** Capture an Error object or string message. */
+    captureError(error: Error | string, options?: ReportOptions): Promise<WebhookResponse | null>;
+    /** Report a custom error message (not from a thrown Error). */
+    captureMessage(message: string, options?: ReportOptions): Promise<WebhookResponse | null>;
+    /** Wrap an async function so errors are automatically captured. */
+    wrap<T extends (...args: unknown[]) => unknown>(fn: T, options?: ReportOptions): T;
+    private buildPayload;
+    private send;
+    private parseStack;
+    private collectBrowserInfo;
+    private getOS;
+    private generateFingerprint;
+}
+/** Create and return the singleton tracker instance. */
+declare function createJahizTracker(config: JahizConfig): JahizTracker;
+/** Get the existing tracker instance. Throws if not initialized. */
+declare function getJahizTracker(): JahizTracker;
+
+interface Props {
+    children: ReactNode;
+    /** Component name for error context (e.g. "CheckoutPage") */
+    component?: string;
+    /** Custom fallback UI when an error is caught */
+    fallback?: ReactNode | ((error: Error, reset: () => void) => ReactNode);
+    /** Extra options applied to every error captured by this boundary */
+    reportOptions?: ReportOptions;
+    /** Callback when an error is caught */
+    onError?: (error: Error, errorInfo: ErrorInfo) => void;
+}
+interface State {
+    hasError: boolean;
+    error: Error | null;
+}
+/**
+ * React Error Boundary that automatically reports caught errors
+ * to the Jahiz webhook and shows a fallback UI.
+ *
+ * Usage:
+ *   <JahizErrorBoundary component="Dashboard" fallback={<ErrorPage />}>
+ *     <Dashboard />
+ *   </JahizErrorBoundary>
+ */
+declare class JahizErrorBoundary extends Component<Props, State> {
+    constructor(props: Props);
+    static getDerivedStateFromError(error: Error): State;
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    private reset;
+    render(): ReactNode;
+}
+
+/**
+ * React hook for reporting errors from components.
+ *
+ * Usage:
+ *   const { captureError, captureMessage } = useJahizTracker("PaymentForm");
+ *
+ *   const handleSubmit = async () => {
+ *     try {
+ *       await processPayment();
+ *     } catch (err) {
+ *       captureError(err, { severity: "critical", metadata: { orderId } });
+ *       showErrorToast("Payment failed");
+ *     }
+ *   };
+ */
+declare function useJahizTracker(component?: string): {
+    captureError: (error: Error | string, options?: ReportOptions) => Promise<WebhookResponse | null>;
+    captureMessage: (message: string, options?: ReportOptions) => Promise<WebhookResponse | null>;
+    setUser: (user: Partial<UserInfo>) => void;
+    clearUser: () => void;
+};
+
+export { type DeviceInfo, type ErrorContext, type ErrorPayload, type JahizConfig, JahizErrorBoundary, JahizTracker, type ReportOptions, type Severity, type UserInfo, type WebhookResponse, createJahizTracker, getJahizTracker, useJahizTracker };

package/dist/index.d.ts

@@ -0,0 +1,166 @@
+import { Component, ReactNode, ErrorInfo } from 'react';
+
+/**
+ * Jahiz Error Tracker - Core Client
+ *
+ * Lightweight client for sending error reports to the Jahiz webhook.
+ * Framework-agnostic. Works in any JS/TS environment (browser, Node, Deno).
+ */
+type Severity = "critical" | "error" | "warning" | "info";
+interface JahizConfig {
+    webhookUrl: string;
+    webhookSecret: string;
+    appName?: string;
+    appVersion?: string;
+    environment?: string;
+    serviceName?: string;
+    /** Automatically capture unhandled errors and promise rejections. Default: true */
+    captureGlobal?: boolean;
+    /** Collect browser/device info automatically. Default: true */
+    collectDeviceInfo?: boolean;
+    /** Custom tags applied to every error report */
+    defaultTags?: Record<string, string>;
+    /** Callback before sending — return false to skip */
+    beforeSend?: (payload: ErrorPayload) => ErrorPayload | false;
+}
+interface UserInfo {
+    userId?: string;
+    username?: string;
+    email?: string;
+    sessionId?: string;
+    ipAddress?: string;
+}
+interface ErrorContext {
+    requestUrl?: string;
+    requestMethod?: string;
+    responseStatus?: number;
+    queryParams?: Record<string, string>;
+}
+interface DeviceInfo {
+    hostname?: string;
+    os?: string;
+    osVersion?: string;
+    architecture?: string;
+    ipAddress?: string;
+}
+interface ErrorPayload {
+    error_message: string;
+    severity: Severity;
+    error_type?: string;
+    error_code?: string;
+    stacktrace?: string;
+    file_name?: string;
+    line_number?: number;
+    function_name?: string;
+    app_name?: string;
+    app_version?: string;
+    environment?: string;
+    service_name?: string;
+    component?: string;
+    context?: Partial<ErrorContext>;
+    user?: Partial<UserInfo>;
+    device?: Partial<DeviceInfo>;
+    tags?: Record<string, string>;
+    metadata?: Record<string, unknown>;
+    fingerprint?: string;
+    timestamp?: string;
+}
+interface WebhookResponse {
+    success: boolean;
+    message: string;
+    error_id?: string;
+    timestamp: string;
+}
+interface ReportOptions {
+    severity?: Severity;
+    component?: string;
+    errorCode?: string;
+    context?: Partial<ErrorContext>;
+    user?: Partial<UserInfo>;
+    tags?: Record<string, string>;
+    metadata?: Record<string, unknown>;
+}
+declare class JahizTracker {
+    private config;
+    private user;
+    private initialized;
+    constructor(config: JahizConfig);
+    /** Initialize the tracker. Call once at app startup. */
+    init(): void;
+    /** Set the current user context. Attached to all subsequent reports. */
+    setUser(user: Partial<UserInfo>): void;
+    /** Clear user context (e.g. on logout). */
+    clearUser(): void;
+    /** Capture an Error object or string message. */
+    captureError(error: Error | string, options?: ReportOptions): Promise<WebhookResponse | null>;
+    /** Report a custom error message (not from a thrown Error). */
+    captureMessage(message: string, options?: ReportOptions): Promise<WebhookResponse | null>;
+    /** Wrap an async function so errors are automatically captured. */
+    wrap<T extends (...args: unknown[]) => unknown>(fn: T, options?: ReportOptions): T;
+    private buildPayload;
+    private send;
+    private parseStack;
+    private collectBrowserInfo;
+    private getOS;
+    private generateFingerprint;
+}
+/** Create and return the singleton tracker instance. */
+declare function createJahizTracker(config: JahizConfig): JahizTracker;
+/** Get the existing tracker instance. Throws if not initialized. */
+declare function getJahizTracker(): JahizTracker;
+
+interface Props {
+    children: ReactNode;
+    /** Component name for error context (e.g. "CheckoutPage") */
+    component?: string;
+    /** Custom fallback UI when an error is caught */
+    fallback?: ReactNode | ((error: Error, reset: () => void) => ReactNode);
+    /** Extra options applied to every error captured by this boundary */
+    reportOptions?: ReportOptions;
+    /** Callback when an error is caught */
+    onError?: (error: Error, errorInfo: ErrorInfo) => void;
+}
+interface State {
+    hasError: boolean;
+    error: Error | null;
+}
+/**
+ * React Error Boundary that automatically reports caught errors
+ * to the Jahiz webhook and shows a fallback UI.
+ *
+ * Usage:
+ *   <JahizErrorBoundary component="Dashboard" fallback={<ErrorPage />}>
+ *     <Dashboard />
+ *   </JahizErrorBoundary>
+ */
+declare class JahizErrorBoundary extends Component<Props, State> {
+    constructor(props: Props);
+    static getDerivedStateFromError(error: Error): State;
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    private reset;
+    render(): ReactNode;
+}
+
+/**
+ * React hook for reporting errors from components.
+ *
+ * Usage:
+ *   const { captureError, captureMessage } = useJahizTracker("PaymentForm");
+ *
+ *   const handleSubmit = async () => {
+ *     try {
+ *       await processPayment();
+ *     } catch (err) {
+ *       captureError(err, { severity: "critical", metadata: { orderId } });
+ *       showErrorToast("Payment failed");
+ *     }
+ *   };
+ */
+declare function useJahizTracker(component?: string): {
+    captureError: (error: Error | string, options?: ReportOptions) => Promise<WebhookResponse | null>;
+    captureMessage: (message: string, options?: ReportOptions) => Promise<WebhookResponse | null>;
+    setUser: (user: Partial<UserInfo>) => void;
+    clearUser: () => void;
+};
+
+export { type DeviceInfo, type ErrorContext, type ErrorPayload, type JahizConfig, JahizErrorBoundary, JahizTracker, type ReportOptions, type Severity, type UserInfo, type WebhookResponse, createJahizTracker, getJahizTracker, useJahizTracker };