@fixflow/sdk 0.1.2 → 0.1.3

package/dist/cjs/capture.js

@@ -0,0 +1,409 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNode = isNode;
+exports.getRuntime = getRuntime;
+exports.extractFile = extractFile;
+exports.extractLine = extractLine;
+exports.capture = capture;
+exports.setupApiTracking = setupApiTracking;
+exports.setupGlobalHandlers = setupGlobalHandlers;
+exports.registerAutoCapture = registerAutoCapture;
+const sender_js_1 = require("./sender.js");
+const core_js_1 = require("./core.js");
+const axios_1 = __importDefault(require("axios"));
+let autoCaptureRegistered = false;
+let fetchTrackingRegistered = false;
+let axiosTrackingRegistered = false;
+function isReactNative() {
+    try {
+        const nav = globalThis.navigator;
+        return nav?.product === "ReactNative";
+    }
+    catch {
+        return false;
+    }
+}
+function isNode() {
+    try {
+        const nodeProcess = globalThis.process;
+        return typeof nodeProcess !== "undefined" && nodeProcess.release?.name === "node";
+    }
+    catch {
+        return false;
+    }
+}
+function getRuntime() {
+    try {
+        if (isReactNative()) {
+            return "react-native";
+        }
+        return isNode() ? "node" : "browser";
+    }
+    catch {
+        return "node";
+    }
+}
+function extractFile(stack) {
+    try {
+        if (!stack) {
+            return undefined;
+        }
+        const match = stack.match(/(?:at\s+.*\()?(.+):\d+:\d+\)?/);
+        return match?.[1];
+    }
+    catch {
+        return undefined;
+    }
+}
+function extractLine(stack) {
+    try {
+        if (!stack) {
+            return undefined;
+        }
+        const match = stack.match(/:(\d+):\d+\)?/);
+        if (!match?.[1]) {
+            return undefined;
+        }
+        const line = Number(match[1]);
+        return Number.isFinite(line) ? line : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function getEnv() {
+    try {
+        const nodeProcess = globalThis.process;
+        if (nodeProcess?.env?.NODE_ENV) {
+            return nodeProcess.env.NODE_ENV;
+        }
+        if (isNode()) {
+            return "production";
+        }
+    }
+    catch {
+        // noop
+    }
+    return "unknown";
+}
+function getNodeVersion() {
+    try {
+        const nodeProcess = globalThis.process;
+        return nodeProcess?.version;
+    }
+    catch {
+        return undefined;
+    }
+}
+function getNodePlatform() {
+    try {
+        const nodeProcess = globalThis.process;
+        return nodeProcess?.platform;
+    }
+    catch {
+        return undefined;
+    }
+}
+function markCaptured(error) {
+    try {
+        if (error.__fixflow) {
+            return true;
+        }
+        error.__fixflow = true;
+        return false;
+    }
+    catch {
+        return true;
+    }
+}
+function normalizeError(input) {
+    try {
+        if (input instanceof Error) {
+            return input;
+        }
+        return new Error(typeof input === "string" ? input : "Unknown error");
+    }
+    catch {
+        return new Error("Unknown error");
+    }
+}
+function normalizeRejectionReason(reason) {
+    try {
+        if (reason instanceof Error) {
+            return reason;
+        }
+        return new Error(JSON.stringify(reason));
+    }
+    catch {
+        return new Error("Unhandled promise rejection");
+    }
+}
+async function capture(error) {
+    try {
+        const safeError = normalizeError(error);
+        if (markCaptured(safeError)) {
+            return;
+        }
+        await (0, sender_js_1.sendError)({
+            message: safeError.message || "Unknown error",
+            stack: safeError.stack,
+            file: extractFile(safeError.stack),
+            line: extractLine(safeError.stack),
+            runtime: getRuntime(),
+            env: getEnv(),
+            nodeVersion: isNode() ? getNodeVersion() : undefined,
+            platform: isNode() ? getNodePlatform() : undefined,
+            type: "error",
+        });
+    }
+    catch {
+        // SDK should never throw
+    }
+}
+async function sendApiEvent(data) {
+    try {
+        await (0, sender_js_1.sendError)({
+            message: data.message,
+            runtime: getRuntime(),
+            env: getEnv(),
+            nodeVersion: isNode() ? getNodeVersion() : undefined,
+            platform: isNode() ? getNodePlatform() : undefined,
+            type: "api",
+            url: data.url,
+            status: data.status,
+            duration: data.duration,
+        });
+    }
+    catch {
+        // SDK should never throw
+    }
+}
+function setupApiTracking() {
+    try {
+        if ((0, core_js_1.shouldTrackFetch)() && !fetchTrackingRegistered && typeof window !== "undefined" && typeof window.fetch === "function") {
+            fetchTrackingRegistered = true;
+            const originalFetch = window.fetch.bind(window);
+            window.fetch = async (...args) => {
+                const start = Date.now();
+                let requestUrl = "";
+                try {
+                    const input = args[0];
+                    requestUrl = typeof input === "string" ? input : input instanceof Request ? input.url : "";
+                }
+                catch {
+                    // noop
+                }
+                try {
+                    const response = await originalFetch(...args);
+                    const duration = Date.now() - start;
+                    const threshold = (0, core_js_1.getSlowThreshold)();
+                    if (!response.ok || duration > threshold) {
+                        void sendApiEvent({
+                            message: !response.ok ? "API request failed" : "API request slow",
+                            url: requestUrl,
+                            status: response.status,
+                            duration,
+                        });
+                    }
+                    return response;
+                }
+                catch (error) {
+                    const duration = Date.now() - start;
+                    void sendApiEvent({
+                        message: "API request error",
+                        url: requestUrl,
+                        duration,
+                    });
+                    throw error;
+                }
+            };
+        }
+        if ((0, core_js_1.shouldTrackAxios)() && !axiosTrackingRegistered) {
+            axiosTrackingRegistered = true;
+            const axiosClient = (0, core_js_1.getTrackingAxios)() ?? axios_1.default;
+            axiosClient.interceptors.request.use((config) => {
+                try {
+                    const meta = config.__fixflowMeta || {
+                        startTime: Date.now(),
+                    };
+                    config.__fixflowMeta = meta;
+                }
+                catch {
+                    // noop
+                }
+                return config;
+            });
+            axiosClient.interceptors.response.use((response) => {
+                try {
+                    const startTime = response.config.__fixflowMeta?.startTime ||
+                        Date.now();
+                    const duration = Date.now() - startTime;
+                    const threshold = (0, core_js_1.getSlowThreshold)();
+                    let requestUrl = "";
+                    try {
+                        requestUrl = axiosClient.getUri(response.config);
+                    }
+                    catch {
+                        requestUrl = response.config?.url || "";
+                    }
+                    if (!response.status || response.status >= 400 || duration > threshold) {
+                        void sendApiEvent({
+                            message: response.status >= 400 ? "API request failed" : "API request slow",
+                            url: requestUrl || response.config?.url,
+                            status: response.status,
+                            duration,
+                        });
+                    }
+                }
+                catch {
+                    // noop
+                }
+                return response;
+            }, (error) => {
+                try {
+                    const config = (error?.config || {});
+                    const startTime = config.__fixflowMeta?.startTime || Date.now();
+                    const duration = Date.now() - startTime;
+                    let requestUrl = "";
+                    try {
+                        requestUrl = axiosClient.getUri(config);
+                    }
+                    catch {
+                        requestUrl = config.url || "";
+                    }
+                    void sendApiEvent({
+                        message: "API request error",
+                        url: requestUrl || config.url,
+                        status: error?.response?.status,
+                        duration,
+                    });
+                }
+                catch {
+                    // noop
+                }
+                return Promise.reject(error);
+            });
+        }
+    }
+    catch {
+        // SDK should never throw
+    }
+}
+function setupGlobalHandlers() {
+    try {
+        if (autoCaptureRegistered) {
+            return;
+        }
+        autoCaptureRegistered = true;
+        const nodeProcess = globalThis.process;
+        if (isNode() && typeof nodeProcess?.on === "function") {
+            nodeProcess.on("uncaughtException", (error) => {
+                try {
+                    void capture(normalizeError(error));
+                }
+                catch {
+                    // noop
+                }
+            });
+            nodeProcess.on("unhandledRejection", (reason) => {
+                try {
+                    void capture(normalizeRejectionReason(reason));
+                }
+                catch {
+                    // noop
+                }
+            });
+            nodeProcess.on("beforeExit", (code) => {
+                try {
+                    console.debug("[FixFlow] process beforeExit", code);
+                }
+                catch {
+                    // noop
+                }
+            });
+            nodeProcess.on("exit", (code) => {
+                try {
+                    console.debug("[FixFlow] process exit", code);
+                }
+                catch {
+                    // noop
+                }
+            });
+        }
+        if (isReactNative()) {
+            const rnGlobal = globalThis;
+            if (typeof rnGlobal.ErrorUtils?.setGlobalHandler === "function") {
+                const previousHandler = typeof rnGlobal.ErrorUtils.getGlobalHandler === "function"
+                    ? rnGlobal.ErrorUtils.getGlobalHandler()
+                    : undefined;
+                rnGlobal.ErrorUtils.setGlobalHandler((error, isFatal) => {
+                    try {
+                        void capture(normalizeError(error));
+                    }
+                    catch {
+                        // noop
+                    }
+                    try {
+                        if (typeof previousHandler === "function") {
+                            previousHandler(error, isFatal);
+                        }
+                    }
+                    catch {
+                        // noop
+                    }
+                });
+            }
+            return;
+        }
+        if (typeof window !== "undefined") {
+            const previousOnError = window.onerror;
+            const previousUnhandledRejection = window.onunhandledrejection;
+            window.onerror = (message, source, lineno, _colno, error) => {
+                try {
+                    const normalized = normalizeError(error ?? message);
+                    if (!normalized.stack && source) {
+                        normalized.stack = `at ${source}:${lineno || 0}:0`;
+                    }
+                    void capture(normalized);
+                }
+                catch {
+                    // noop
+                }
+                try {
+                    if (typeof previousOnError === "function") {
+                        return previousOnError(message, source, lineno, _colno, error);
+                    }
+                }
+                catch {
+                    // noop
+                }
+                return false;
+            };
+            window.onunhandledrejection = (event) => {
+                try {
+                    void capture(normalizeRejectionReason(event.reason));
+                }
+                catch {
+                    // noop
+                }
+                try {
+                    if (typeof previousUnhandledRejection === "function") {
+                        previousUnhandledRejection.call(window, event);
+                    }
+                }
+                catch {
+                    // noop
+                }
+            };
+        }
+    }
+    catch {
+        // SDK should never throw
+    }
+}
+function registerAutoCapture() {
+    setupGlobalHandlers();
+}

package/dist/cjs/core.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initConfig = initConfig;
+exports.getTrackingAxios = getTrackingAxios;
+exports.getProjectKey = getProjectKey;
+exports.getEndpoint = getEndpoint;
+exports.isInitialized = isInitialized;
+exports.shouldTrackFetch = shouldTrackFetch;
+exports.shouldTrackAxios = shouldTrackAxios;
+exports.getSlowThreshold = getSlowThreshold;
+exports.syncRemoteApiTrackingConfig = syncRemoteApiTrackingConfig;
+const DEFAULT_ENDPOINT = "https://api.tryfixflow.com/sdk/error";
+const DEFAULT_SLOW_THRESHOLD = 1000;
+let projectKey = "";
+let endpoint = DEFAULT_ENDPOINT;
+let trackFetch = false;
+let trackAxios = false;
+let slowThreshold = DEFAULT_SLOW_THRESHOLD;
+let trackingAxios;
+let remoteApiTrackingEnabled = null;
+let remoteTrackInDevelopment = false;
+function initConfig(key, options) {
+    try {
+        if (typeof key !== "string" || key.trim() === "") {
+            return;
+        }
+        projectKey = key;
+        endpoint = options?.endpoint || DEFAULT_ENDPOINT;
+        trackFetch = Boolean(options?.trackFetch);
+        trackAxios = Boolean(options?.trackAxios);
+        slowThreshold =
+            typeof options?.slowThreshold === "number" && Number.isFinite(options.slowThreshold)
+                ? Math.max(0, options.slowThreshold)
+                : DEFAULT_SLOW_THRESHOLD;
+        trackingAxios = options?.axios;
+    }
+    catch {
+        // SDK should never throw
+    }
+}
+function getTrackingAxios() {
+    try {
+        return trackingAxios;
+    }
+    catch {
+        return undefined;
+    }
+}
+function getProjectKey() {
+    try {
+        return projectKey;
+    }
+    catch {
+        return "";
+    }
+}
+function getEndpoint() {
+    try {
+        return endpoint || DEFAULT_ENDPOINT;
+    }
+    catch {
+        return DEFAULT_ENDPOINT;
+    }
+}
+function isInitialized() {
+    try {
+        return Boolean(projectKey);
+    }
+    catch {
+        return false;
+    }
+}
+function shouldTrackFetch() {
+    try {
+        const enabled = remoteApiTrackingEnabled !== null ? remoteApiTrackingEnabled : trackFetch;
+        if (!enabled)
+            return false;
+        if (isDevelopmentEnvironment() && !remoteTrackInDevelopment)
+            return false;
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function shouldTrackAxios() {
+    try {
+        const enabled = remoteApiTrackingEnabled !== null ? remoteApiTrackingEnabled : trackAxios;
+        if (!enabled)
+            return false;
+        if (isDevelopmentEnvironment() && !remoteTrackInDevelopment)
+            return false;
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function getSlowThreshold() {
+    try {
+        return slowThreshold;
+    }
+    catch {
+        return DEFAULT_SLOW_THRESHOLD;
+    }
+}
+function getSdkConfigEndpoint() {
+    const base = getEndpoint().replace(/\/+$/, "");
+    if (base.endsWith("/sdk/error")) {
+        const suffix = "/sdk/error";
+        return `${base.slice(0, -suffix.length)}/sdk/config`;
+    }
+    return `${base}/config`;
+}
+async function syncRemoteApiTrackingConfig() {
+    try {
+        const key = getProjectKey();
+        if (!key)
+            return;
+        const configUrl = `${getSdkConfigEndpoint()}/${encodeURIComponent(key)}`;
+        const response = await fetch(configUrl, { method: "GET" });
+        if (!response.ok)
+            return;
+        const data = (await response.json());
+        if (typeof data?.apiTrackingEnabled === "boolean") {
+            remoteApiTrackingEnabled = data.apiTrackingEnabled;
+        }
+        if (typeof data?.trackInDevelopment === "boolean") {
+            remoteTrackInDevelopment = data.trackInDevelopment;
+        }
+    }
+    catch {
+        // SDK should never throw
+    }
+}
+function isDevelopmentEnvironment() {
+    try {
+        const processObj = globalThis.process;
+        const env = processObj?.env || {};
+        const value = env.ENVIRONMENT || env.NODE_ENV || "";
+        return String(value).toLowerCase() === "development";
+    }
+    catch {
+        return false;
+    }
+}

package/dist/cjs/index.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capture = void 0;
+exports.init = init;
+exports.captureError = captureError;
+const core_js_1 = require("./core.js");
+const capture_js_1 = require("./capture.js");
+Object.defineProperty(exports, "capture", { enumerable: true, get: function () { return capture_js_1.capture; } });
+function init(projectKey, options) {
+    try {
+        (0, core_js_1.initConfig)(projectKey, options);
+        (0, capture_js_1.registerAutoCapture)();
+        void (0, core_js_1.syncRemoteApiTrackingConfig)().finally(() => {
+            (0, capture_js_1.setupApiTracking)();
+        });
+    }
+    catch {
+        // SDK should never throw
+    }
+}
+function captureError(error) {
+    try {
+        void (0, capture_js_1.capture)(error);
+    }
+    catch {
+        // SDK should never throw
+    }
+}
+const fixflow = {
+    init,
+    capture: capture_js_1.capture,
+    captureError,
+};
+exports.default = fixflow;

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type": "commonjs"}

package/dist/cjs/sender.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendError = sendError;
+const axios_1 = __importDefault(require("axios"));
+const core_js_1 = require("./core.js");
+async function sendError(payload) {
+    try {
+        if (!(0, core_js_1.isInitialized)()) {
+            return;
+        }
+        const key = (0, core_js_1.getProjectKey)();
+        const endpoint = (0, core_js_1.getEndpoint)();
+        if (!key || !endpoint) {
+            return;
+        }
+        await axios_1.default.post(endpoint, {
+            projectKey: key,
+            message: payload.message,
+            stack: payload.stack,
+            file: payload.file,
+            line: payload.line,
+            runtime: payload.runtime,
+            env: payload.env,
+            nodeVersion: payload.nodeVersion,
+            platform: payload.platform,
+            type: payload.type,
+            url: payload.url,
+            status: payload.status,
+            duration: payload.duration,
+        });
+    }
+    catch {
+        // Silent fail by design
+    }
+}

package/dist/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/esm/capture.d.ts

@@ -0,0 +1,9 @@
+import type { Runtime } from "./types.js";
+export declare function isNode(): boolean;
+export declare function getRuntime(): Runtime;
+export declare function extractFile(stack?: string): string | undefined;
+export declare function extractLine(stack?: string): number | undefined;
+export declare function capture(error: Error): Promise<void>;
+export declare function setupApiTracking(): void;
+export declare function setupGlobalHandlers(): void;
+export declare function registerAutoCapture(): void;

package/dist/esm/core.d.ts

@@ -0,0 +1,11 @@
+import type { AxiosStatic } from "axios";
+import type { InitOptions } from "./types.js";
+export declare function initConfig(key: string, options?: InitOptions): void;
+export declare function getTrackingAxios(): AxiosStatic | undefined;
+export declare function getProjectKey(): string;
+export declare function getEndpoint(): string;
+export declare function isInitialized(): boolean;
+export declare function shouldTrackFetch(): boolean;
+export declare function shouldTrackAxios(): boolean;
+export declare function getSlowThreshold(): number;
+export declare function syncRemoteApiTrackingConfig(): Promise<void>;

package/dist/esm/index.d.ts

@@ -0,0 +1,11 @@
+import { capture } from "./capture.js";
+import type { InitOptions } from "./types.js";
+export declare function init(projectKey: string, options?: InitOptions): void;
+export { capture };
+export declare function captureError(error: Error): void;
+declare const fixflow: {
+    init: typeof init;
+    capture: typeof capture;
+    captureError: typeof captureError;
+};
+export default fixflow;

package/dist/esm/package.json

@@ -0,0 +1 @@
+{"type": "module"}

package/dist/esm/sender.d.ts

@@ -0,0 +1,2 @@
+import type { ErrorPayload } from "./types.js";
+export declare function sendError(payload: Omit<ErrorPayload, "projectKey">): Promise<void>;

package/dist/esm/types.d.ts

@@ -0,0 +1,33 @@
+import type { AxiosStatic } from "axios";
+export interface InitOptions {
+    /** Override ingest URL. Defaults to `https://api.fixflow.ai/sdk/error`. Only set for self-hosted APIs. */
+    endpoint?: string;
+    trackFetch?: boolean;
+    trackAxios?: boolean;
+    slowThreshold?: number;
+    /**
+     * Your application's `axios` import. Required in Node when `trackAxios` is true:
+     * npm often installs a separate `axios` copy inside `@fixflow/sdk`, so interceptors
+     * on the SDK's default axios would not see requests made with your app's axios.
+     */
+    axios?: AxiosStatic;
+}
+export type Runtime = "node" | "browser" | "react-native";
+export interface ErrorPayload {
+    projectKey: string;
+    message: string;
+    stack?: string;
+    file?: string;
+    line?: number;
+    runtime: Runtime;
+    env: string;
+    nodeVersion?: string;
+    platform?: string;
+    type?: "error" | "api";
+    url?: string;
+    status?: number;
+    duration?: number;
+}
+export type FixflowError = Error & {
+    __fixflow?: boolean;
+};

package/package.json

@@ -1,14 +1,24 @@
 {
   "name": "@fixflow/sdk",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "FixFlow SDK for error capture",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "license": "MIT",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/index.d.ts",
   "type": "module",
-  "files": ["dist"],
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
   "scripts": {
-    "build": "tsc"
+    "build": "rm -rf dist && tsc && echo '{\"type\": \"commonjs\"}' > dist/cjs/package.json && tsc -p tsconfig.esm.json && echo '{\"type\": \"module\"}' > dist/esm/package.json"
   },
   "dependencies": {
     "axios": "^1.13.0"
@@ -24,4 +34,4 @@
   "devDependencies": {
     "typescript": "^5.9.2"
   }
-}
+}