@hawk.so/nextjs 1.0.0 → 1.1.0

package/dist/server.js

@@ -0,0 +1,452 @@
+// src/server/sdk.ts
+import { isLoggerSet, log, setLogger } from "@hawk.so/core";
+
+// src/common/carrier.ts
+var CARRIER_KEY = /* @__PURE__ */ Symbol.for("hawk.nextjs");
+function getCarrier() {
+  const store = globalThis;
+  store[CARRIER_KEY] ??= {};
+  return store[CARRIER_KEY];
+}
+
+// src/common/control-flow.ts
+var CONTROL_FLOW_DIGEST_PREFIXES = [
+  "NEXT_REDIRECT",
+  "NEXT_HTTP_ERROR_FALLBACK;",
+  "NEXT_NOT_FOUND",
+  "BAILOUT_TO_CLIENT_SIDE_RENDERING",
+  "DYNAMIC_SERVER_USAGE",
+  "NEXT_PRERENDER_INTERRUPTED",
+  "HANGING_PROMISE_REJECTION"
+];
+var STATIC_GEN_BAILOUT_CODE = "NEXT_STATIC_GEN_BAILOUT";
+var REACT_POSTPONE_TYPE = /* @__PURE__ */ Symbol.for("react.postpone");
+var MAX_CAUSE_DEPTH = 5;
+function isControlFlowDigest(value) {
+  return typeof value === "string" && CONTROL_FLOW_DIGEST_PREFIXES.some((prefix) => value.startsWith(prefix));
+}
+function isNextControlFlowError(error) {
+  let current = error;
+  for (let depth = 0; depth < MAX_CAUSE_DEPTH; depth++) {
+    if (typeof current !== "object" || current === null) {
+      return false;
+    }
+    const value = current;
+    if (isControlFlowDigest(value.digest) || isControlFlowDigest(value.message) || value.code === STATIC_GEN_BAILOUT_CODE || value.$$typeof === REACT_POSTPONE_TYPE) {
+      return true;
+    }
+    current = value.cause;
+  }
+  return false;
+}
+function getDigest(error) {
+  if (typeof error === "object" && error !== null) {
+    const { digest } = error;
+    if (typeof digest === "string" && digest !== "") {
+      return digest;
+    }
+  }
+  return void 0;
+}
+
+// src/common/error.ts
+function isErrorLike(value) {
+  return typeof value === "object" && value !== null && typeof value.message === "string" && typeof value.stack === "string";
+}
+function normalizeError(value) {
+  if (value instanceof Error || typeof value === "string") {
+    return value;
+  }
+  if (isErrorLike(value)) {
+    const error = new Error(value.message);
+    error.name = typeof value.name === "string" ? value.name : error.name;
+    error.stack = value.stack;
+    return error;
+  }
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch (_error) {
+    return String(value);
+  }
+}
+
+// src/common/options.ts
+var DEFAULT_FLUSH_TIMEOUT = 2e3;
+
+// src/common/request.ts
+var SAFE_HEADERS = ["host", "referer", "user-agent"];
+function pickSafeHeaders(headers) {
+  const result = {};
+  for (const name of SAFE_HEADERS) {
+    const value = headers[name];
+    if (value !== void 0) {
+      result[name] = Array.isArray(value) ? value.join(", ") : value;
+    }
+  }
+  return result;
+}
+function getRequestAddons(error, request, context) {
+  const addons = {
+    digest: getDigest(error),
+    routerKind: context.routerKind,
+    routePath: context.routePath,
+    routeType: context.routeType,
+    renderSource: context.renderSource,
+    revalidateReason: context.revalidateReason,
+    renderType: context.renderType,
+    method: request.method,
+    path: request.path,
+    headers: pickSafeHeaders(request.headers)
+  };
+  return Object.fromEntries(Object.entries(addons).filter(([, value]) => value !== void 0));
+}
+
+// src/server/catcher.ts
+import { BaseCatcher, decodeIntegrationId, HawkUserManager } from "@hawk.so/core";
+
+// src/common/timeout.ts
+async function settleWithTimeout(promises, timeout) {
+  const list = [...promises];
+  if (list.length === 0) {
+    return true;
+  }
+  let timer;
+  const timeoutReached = new Promise((resolve) => {
+    timer = setTimeout(() => resolve(false), timeout);
+  });
+  const allSettled = Promise.allSettled(list).then(() => true);
+  try {
+    return await Promise.race([allSettled, timeoutReached]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/common/version.ts
+var VERSION = true ? "1.1.0" : "dev";
+
+// src/server/stack-parser.ts
+import { StackParser } from "@hawk.so/core";
+import ErrorStackParser from "error-stack-parser";
+var ServerStackParser = class extends StackParser {
+  /**
+   * Returns frames of the stack trace
+   * @param error - error with the stack trace
+   */
+  parse(error) {
+    const frames = ErrorStackParser.parse(error).map((frame) => ({
+      file: frame.fileName ?? "",
+      line: frame.lineNumber ?? 0,
+      column: frame.columnNumber,
+      function: frame.functionName,
+      arguments: frame.args
+    }));
+    return Promise.resolve(frames);
+  }
+};
+
+// src/server/transport.ts
+var REQUEST_TIMEOUT = 1e4;
+var FetchTransport = class {
+  /**
+   * Collector endpoint
+   */
+  endpoint;
+  /**
+   * Requests in progress
+   */
+  pending = /* @__PURE__ */ new Set();
+  /**
+   * @param endpoint - collector endpoint, e.g. `https://<integration id>.k1.hawk.so/`
+   */
+  constructor(endpoint) {
+    this.endpoint = endpoint;
+  }
+  /**
+   * Sends the event
+   * @param message - event with the token and the catcher type
+   */
+  send(message) {
+    const request = this.post(message).finally(() => {
+      this.pending.delete(request);
+    });
+    this.pending.add(request);
+    return request;
+  }
+  /**
+   * Waits for the requests in progress
+   * @param timeout - max time to wait, in milliseconds
+   * @returns false when the timeout is reached
+   */
+  flush(timeout) {
+    return settleWithTimeout(this.pending, timeout);
+  }
+  /**
+   * Posts the event to the collector
+   * @param message - event with the token and the catcher type
+   */
+  async post(message) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT);
+    try {
+      const response = await fetch(this.endpoint, {
+        method: "POST",
+        headers: [["Content-Type", "application/json"]],
+        body: JSON.stringify(message),
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(`Collector responded with ${response.status} ${response.statusText}`);
+      }
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+
+// src/server/catcher.ts
+var usersByError = /* @__PURE__ */ new WeakMap();
+var noopStorage = {
+  getItem: () => null,
+  setItem: () => void 0,
+  removeItem: () => void 0
+};
+var zeroRandomGenerator = {
+  getRandomNumbers: (length) => new Uint8Array(length)
+};
+var ServerUserManager = class extends HawkUserManager {
+  /**
+   * Creates a manager that never stores the user
+   */
+  constructor() {
+    super(noopStorage, zeroRandomGenerator);
+  }
+};
+var ServerUserProcessor = class {
+  /**
+   * @param payload - event being built
+   * @param error - sent error
+   */
+  apply(payload, error) {
+    const user = typeof error === "object" ? usersByError.get(error) : void 0;
+    if (user !== void 0) {
+      payload.user = user;
+    } else {
+      delete payload.user;
+    }
+    return payload;
+  }
+};
+function getDefaultEndpoint(token) {
+  return `https://${decodeIntegrationId(token)}.k1.hawk.so/`;
+}
+var ServerCatcher = class extends BaseCatcher {
+  /**
+   * Transport kept to wait for the events in progress
+   */
+  fetchTransport;
+  /**
+   * Current runtime: `nodejs` or `edge`
+   */
+  runtime;
+  /**
+   * Events being built: the stack trace is parsed asynchronously before the event gets to the transport
+   */
+  pending = /* @__PURE__ */ new Set();
+  /**
+   * @param settings - token, release and other settings
+   * @throws when the token is invalid and the collector endpoint is not set
+   */
+  constructor(settings) {
+    const transport = new FetchTransport(settings.collectorEndpoint ?? getDefaultEndpoint(settings.token));
+    super(settings.token, transport, new ServerUserManager(), settings.release, settings.context, settings.beforeSend);
+    this.fetchTransport = transport;
+    this.runtime = settings.runtime;
+    this.addMessageProcessor(new ServerUserProcessor());
+    this.stackParser = new ServerStackParser();
+  }
+  /**
+   * Sends the error and resolves when it is passed to the transport
+   * @param error - error or message
+   * @param options - context, user and Next.js data of the event
+   */
+  capture(error, options = {}) {
+    if (options.user !== void 0 && typeof error === "object") {
+      usersByError.set(error, options.user);
+    }
+    const addons = {
+      runtime: this.runtime,
+      ...options.addons
+    };
+    const building = this.formatAndSend(error, { nextjs: addons }, options.context).finally(() => {
+      this.pending.delete(building);
+    });
+    this.pending.add(building);
+    return building;
+  }
+  /**
+   * Waits for the events being built and sent
+   * @param timeout - max time to wait, in milliseconds
+   * @returns false when the timeout is reached
+   */
+  async flush(timeout) {
+    const deadline = Date.now() + timeout;
+    if (!await settleWithTimeout(this.pending, timeout)) {
+      return false;
+    }
+    return this.fetchTransport.flush(Math.max(deadline - Date.now(), 0));
+  }
+  /**
+   * Returns the catcher type
+   */
+  getCatcherType() {
+    return "errors/nodejs";
+  }
+  /**
+   * Returns the catcher version
+   */
+  getCatcherVersion() {
+    return VERSION;
+  }
+};
+
+// src/server/sdk.ts
+var REQUEST_CONTEXT_KEY = /* @__PURE__ */ Symbol.for("@next/request-context");
+var noopBreadcrumbs = {
+  add: () => void 0,
+  get: () => [],
+  clear: () => void 0
+};
+var isSetUserWarningShown = false;
+function getCatcher() {
+  return getCarrier().catcher;
+}
+function setConsoleLogger() {
+  if (isLoggerSet()) {
+    return;
+  }
+  setLogger((message, type = "log", args) => {
+    const method = type === "warn" || type === "error" || type === "info" ? type : "log";
+    const text = `\u{1F985} Hawk | ${message}`;
+    if (args === void 0) {
+      console[method](text);
+    } else {
+      console[method](text, args);
+    }
+  });
+}
+function getEnvToken() {
+  return [process.env.HAWK_TOKEN, process.env.NEXT_PUBLIC_HAWK_TOKEN].find((value) => value !== void 0 && value !== "");
+}
+function waitUntil(promise) {
+  globalThis[REQUEST_CONTEXT_KEY]?.get?.()?.waitUntil?.(promise);
+}
+function initServerCatcher(options, runtime) {
+  const carrier = getCarrier();
+  if (carrier.catcher !== void 0) {
+    return void 0;
+  }
+  setConsoleLogger();
+  const token = options.token ?? getEnvToken();
+  if (token === void 0 || token === "") {
+    log("Integration Token is not provided, errors will not be sent. Set NEXT_PUBLIC_HAWK_TOKEN or pass `token` to init()", "warn");
+    return void 0;
+  }
+  try {
+    carrier.catcher = new ServerCatcher({
+      token,
+      release: options.release ?? process.env.HAWK_RELEASE,
+      context: options.context,
+      beforeSend: options.beforeSend,
+      collectorEndpoint: options.collectorEndpoint,
+      runtime
+    });
+  } catch (_error) {
+    log("Invalid Integration Token, errors will not be sent", "error");
+    return void 0;
+  }
+  const { catcher } = carrier;
+  carrier.capture = (error, addons) => {
+    void catcher.capture(normalizeError(error), { addons });
+  };
+  return catcher;
+}
+async function captureServerError(error, options = {}) {
+  const catcher = getCatcher();
+  if (catcher === void 0 || isNextControlFlowError(error)) {
+    return;
+  }
+  await catcher.capture(normalizeError(error), options);
+}
+function send(error, context, user) {
+  void captureServerError(error, {
+    context,
+    user
+  });
+}
+function setUser(_user) {
+  if (!isSetUserWarningShown) {
+    isSetUserWarningShown = true;
+    log("setUser() is ignored on the server, pass the user to send() instead", "warn");
+  }
+}
+function clearUser() {
+}
+function setContext(context) {
+  getCatcher()?.setContext(context);
+}
+var breadcrumbs = noopBreadcrumbs;
+async function flush(timeout = DEFAULT_FLUSH_TIMEOUT) {
+  const catcher = getCatcher();
+  return catcher === void 0 ? false : catcher.flush(timeout);
+}
+async function onRequestError(error, request, context) {
+  const catcher = getCatcher();
+  if (catcher === void 0 || isNextControlFlowError(error)) {
+    return;
+  }
+  const sending = captureServerError(error, {
+    addons: getRequestAddons(error, request, context)
+  }).then(() => catcher.flush(DEFAULT_FLUSH_TIMEOUT));
+  waitUntil(sending);
+  await sending;
+}
+function onRouterTransitionStart(_url, _navigationType) {
+}
+
+// src/server/index.ts
+import { HawkErrorBoundary, HawkGlobalError, useHawkError } from "./react.js";
+async function handleProcessError(event, error) {
+  await captureServerError(error);
+  await flush();
+  if (process.listenerCount(event) === 1) {
+    console.error(error);
+    process.exit(1);
+  }
+}
+function init(options = {}) {
+  const catcher = initServerCatcher(options, "nodejs");
+  if (catcher === void 0 || options.disableGlobalErrorsHandling === true) {
+    return;
+  }
+  process.on("uncaughtException", (error) => {
+    void handleProcessError("uncaughtException", error);
+  });
+  process.on("unhandledRejection", (reason) => {
+    void handleProcessError("unhandledRejection", reason);
+  });
+}
+export {
+  HawkErrorBoundary,
+  HawkGlobalError,
+  breadcrumbs,
+  clearUser,
+  flush,
+  init,
+  onRequestError,
+  onRouterTransitionStart,
+  send,
+  setContext,
+  setUser,
+  useHawkError
+};

package/package.json

@@ -1,30 +1,39 @@
 {
   "name": "@hawk.so/nextjs",
-  "version": "1.0.0",
-  "description": "Next.js integration for sending releases with source maps to Hawk",
+  "version": "1.1.0",
+  "description": "Hawk error tracking for Next.js: catches errors in the browser, Node.js and Edge, sends releases with source maps",
   "keywords": [
     "hawk",
     "nextjs",
+    "error tracking",
     "turbopack",
-    "source maps",
-    "error tracking"
+    "source maps"
   ],
   "repository": "https://github.com/codex-team/hawk.nextjs.git",
   "author": "CodeX <team@codex.so>",
   "license": "MIT",
   "type": "module",
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
+  "main": "./dist/server.cjs",
+  "module": "./dist/server.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
+      "edge-light": "./dist/edge.js",
+      "worker": "./dist/edge.js",
+      "workerd": "./dist/edge.js",
+      "browser": "./dist/client.js",
+      "import": "./dist/server.js",
+      "require": "./dist/server.cjs"
+    },
+    "./config": {
       "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
+        "types": "./dist/config.d.ts",
+        "default": "./dist/config.js"
       },
       "require": {
-        "types": "./dist/index.d.cts",
-        "default": "./dist/index.cjs"
+        "types": "./dist/config.d.cts",
+        "default": "./dist/config.cjs"
       }
     },
     "./global": {
@@ -36,6 +45,7 @@
     "dist",
     "global.d.ts"
   ],
+  "sideEffects": false,
   "workspaces": [
     "example"
   ],
@@ -43,7 +53,7 @@
     "node": ">=20.9.0"
   },
   "scripts": {
-    "build": "tsup",
+    "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsup",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "typecheck": "tsc --noEmit",
@@ -52,19 +62,34 @@
     "e2e": "yarn build && node scripts/e2e.mjs",
     "prepublishOnly": "yarn build"
   },
+  "dependencies": {
+    "@hawk.so/browser": "^3.4.0",
+    "@hawk.so/core": "^1.0.0",
+    "@hawk.so/types": "^0.5.8",
+    "error-stack-parser": "^2.1.4"
+  },
   "peerDependencies": {
-    "next": ">=15.4.1"
+    "next": ">=15.4.1",
+    "react": "^18.2.0 || ^19.0.0"
   },
   "devDependencies": {
     "@types/node": "^24.19.2",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.2.0",
+    "@types/ws": "^8.18.2",
     "eslint": "^9.39.5",
     "eslint-config-codex": "^2.0.3",
+    "happy-dom": "^21.0.4",
     "next": "^16.4.3",
+    "playwright": "^1.64.1",
+    "react": "^19.3.1",
+    "react-dom": "^19.3.1",
     "tsup": "^9.0.0",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.70.0",
     "vite": "^8.0.0",
-    "vitest": "^5.0.5"
+    "vitest": "^5.0.5",
+    "ws": "^8.22.0"
   },
   "packageManager": "yarn@4.18.1"
 }