nextly 0.0.1 → 0.0.2-alpha.1

package/dist/chunk-TO5AFLVQ.mjs

@@ -0,0 +1,124 @@
+import {
+  readOrGenerateRequestId
+} from "./chunk-67GXH6PR.mjs";
+import {
+  getGlobalOnError
+} from "./chunk-2TFX4ND3.mjs";
+import {
+  getNextlyLogger
+} from "./chunk-W4MGXIRR.mjs";
+import {
+  NextlyError,
+  isDbError
+} from "./chunk-NRUWQ5Z7.mjs";
+
+// src/api/with-error-handler.ts
+import { createRequire } from "module";
+var cachedUnstableRethrow = null;
+function getUnstableRethrow() {
+  if (cachedUnstableRethrow) return cachedUnstableRethrow;
+  const require2 = createRequire(import.meta.url);
+  const mod = require2("next/navigation");
+  cachedUnstableRethrow = mod.unstable_rethrow;
+  return cachedUnstableRethrow;
+}
+var DEFAULT_INTERNAL_MESSAGE = "An unexpected error occurred.";
+function withErrorHandler(handler, options) {
+  const internalMessage = options?.internalErrorMessage ?? DEFAULT_INTERNAL_MESSAGE;
+  return async (...args) => {
+    const req = args[0];
+    const requestId = readOrGenerateRequestId(req);
+    const route = (() => {
+      try {
+        return new URL(req.url).pathname;
+      } catch {
+        return void 0;
+      }
+    })();
+    const method = req.method;
+    let response;
+    try {
+      response = await handler(...args);
+    } catch (err) {
+      getUnstableRethrow()(err);
+      let nextlyErr;
+      if (NextlyError.is(err)) {
+        nextlyErr = err;
+      } else if (isDbError(err)) {
+        getNextlyLogger().warn({
+          kind: "stray-db-error-converted",
+          requestId,
+          route,
+          method,
+          dbKind: err.kind
+        });
+        nextlyErr = NextlyError.fromDatabaseError(err);
+      } else {
+        nextlyErr = NextlyError.internal({ cause: err });
+      }
+      getNextlyLogger().error({
+        kind: "route-handler-error",
+        ...nextlyErr.toLogJSON(requestId),
+        route,
+        method
+      });
+      const ctx = {
+        kind: "route-handler",
+        requestId,
+        route,
+        method,
+        request: req
+      };
+      if (options?.onError) {
+        try {
+          await options.onError(nextlyErr, ctx);
+        } catch (hookErr) {
+          getNextlyLogger().warn({
+            kind: "onError-hook-failed",
+            layer: "per-call",
+            requestId,
+            err: String(hookErr)
+          });
+        }
+      }
+      const globalHook = getGlobalOnError();
+      if (globalHook) {
+        try {
+          await globalHook(nextlyErr, ctx);
+        } catch (hookErr) {
+          getNextlyLogger().warn({
+            kind: "onError-hook-failed",
+            layer: "global",
+            requestId,
+            err: String(hookErr)
+          });
+        }
+      }
+      const responseJson = nextlyErr.toResponseJSON(requestId);
+      if (nextlyErr.code === "INTERNAL_ERROR" && options?.internalErrorMessage !== void 0) {
+        responseJson.message = internalMessage;
+      }
+      const responseHeaders = {
+        "content-type": "application/problem+json"
+      };
+      if (nextlyErr.code === "RATE_LIMITED") {
+        const data = nextlyErr.publicData;
+        if (data && "retryAfterSeconds" in data && typeof data.retryAfterSeconds === "number") {
+          responseHeaders["retry-after"] = String(data.retryAfterSeconds);
+        }
+      }
+      response = new Response(JSON.stringify({ error: responseJson }), {
+        status: nextlyErr.statusCode,
+        headers: responseHeaders
+      });
+    }
+    if (!response.headers.has("x-request-id")) {
+      response.headers.set("x-request-id", requestId);
+    }
+    return response;
+  };
+}
+
+export {
+  withErrorHandler
+};