@sentry/tanstackstart-react 10.53.0 → 10.54.0

package/build/esm/server/middleware.js

@@ -2,109 +2,53 @@ import { addNonEnumerableProperty } from '@sentry/core';
 import { getActiveSpan, startSpanManual, withActiveSpan } from '@sentry/node';
 import { getMiddlewareSpanOptions } from './utils.js';
 
-const SENTRY_WRAPPED = '__SENTRY_WRAPPED__';
-const SENTRY_INTERNAL = '__SENTRY_INTERNAL__';
-
-/**
- * Creates a proxy for the next function that ends the current span and restores the parent span.
- * This ensures that subsequent middleware spans are children of the root span, not nested children.
- */
-function getNextProxy(
-  next,
-  span,
-  prevSpan,
-  nextState,
-) {
+const SENTRY_WRAPPED = "__SENTRY_WRAPPED__";
+const SENTRY_INTERNAL = "__SENTRY_INTERNAL__";
+function getNextProxy(next, span, prevSpan, nextState) {
   return new Proxy(next, {
     apply: (originalNext, thisArgNext, argsNext) => {
       nextState.called = true;
       span.end();
-
       if (prevSpan) {
         return withActiveSpan(prevSpan, () => {
           return Reflect.apply(originalNext, thisArgNext, argsNext);
         });
       }
-
       return Reflect.apply(originalNext, thisArgNext, argsNext);
-    },
+    }
   });
 }
-
-/**
- * Wraps a TanStack Start middleware with Sentry instrumentation to create spans.
- */
-function wrapMiddlewareWithSentry(
-  middleware,
-  options,
-) {
-  if (
-    (middleware )[SENTRY_WRAPPED] ||
-    (middleware )[SENTRY_INTERNAL]
-  ) {
-    // already instrumented or internal Sentry middleware
+function wrapMiddlewareWithSentry(middleware, options) {
+  if (middleware[SENTRY_WRAPPED] || middleware[SENTRY_INTERNAL]) {
     return middleware;
   }
-
-  // instrument server middleware
   if (middleware.options?.server) {
     middleware.options.server = new Proxy(middleware.options.server, {
       apply: (originalServer, thisArgServer, argsServer) => {
         const prevSpan = getActiveSpan();
-
         return startSpanManual(getMiddlewareSpanOptions(options.name), async (span) => {
           const nextState = { called: false };
-
-          // The server function receives { next, context, request } as first argument
-          // Users call next() inside their middleware to move down the middleware chain. We proxy next() to end the span when it is called.
-          const middlewareArgs = argsServer[0] ;
-          if (middlewareArgs && typeof middlewareArgs === 'object' && typeof middlewareArgs.next === 'function') {
+          const middlewareArgs = argsServer[0];
+          if (middlewareArgs && typeof middlewareArgs === "object" && typeof middlewareArgs.next === "function") {
             middlewareArgs.next = getNextProxy(middlewareArgs.next, span, prevSpan, nextState);
           }
-
           try {
             const result = await originalServer.apply(thisArgServer, argsServer);
-
-            // End span here if next() wasn't called, else we already ended it in next()
             if (!nextState.called) {
               span.end();
             }
-
             return result;
           } catch (e) {
             span.end();
             throw e;
           }
         });
-      },
+      }
     });
-
-    // mark as instrumented
-    addNonEnumerableProperty(middleware , SENTRY_WRAPPED, true);
+    addNonEnumerableProperty(middleware, SENTRY_WRAPPED, true);
   }
-
   return middleware;
 }
-
-/**
- * Wraps multiple TanStack Start middlewares with Sentry instrumentation.
- * Object keys are used as span names to avoid users having to specify this manually.
- *
- * @example
- * ```ts
- * import { wrapMiddlewaresWithSentry } from '@sentry/tanstackstart-react';
- *
- * const wrappedMiddlewares = wrapMiddlewaresWithSentry({
- *   authMiddleware,
- *   loggingMiddleware,
- * });
- *
- * createServerFn().middleware(wrappedMiddlewares)
- * ```
- *
- * @param middlewares - An object containing middlewares
- * @returns An array of wrapped middlewares
- */
 function wrapMiddlewaresWithSentry(middlewares) {
   return Object.entries(middlewares).map(([name, middleware]) => {
     return wrapMiddlewareWithSentry(middleware, { name });

package/build/esm/server/middleware.js.map

@@ -1 +1 @@
-{"version":3,"file":"middleware.js","sources":["../../../src/server/middleware.ts"],"sourcesContent":["import { addNonEnumerableProperty } from '@sentry/core';\nimport type { Span } from '@sentry/node';\nimport { getActiveSpan, startSpanManual, withActiveSpan } from '@sentry/node';\nimport type { MiddlewareWrapperOptions, TanStackMiddlewareBase } from '../common/types';\nimport { getMiddlewareSpanOptions } from './utils';\n\nconst SENTRY_WRAPPED = '__SENTRY_WRAPPED__';\nexport const SENTRY_INTERNAL = '__SENTRY_INTERNAL__';\n\n/**\n * Creates a proxy for the next function that ends the current span and restores the parent span.\n * This ensures that subsequent middleware spans are children of the root span, not nested children.\n */\nfunction getNextProxy<T extends (...args: unknown[]) => unknown>(\n  next: T,\n  span: Span,\n  prevSpan: Span | undefined,\n  nextState: { called: boolean },\n): T {\n  return new Proxy(next, {\n    apply: (originalNext, thisArgNext, argsNext) => {\n      nextState.called = true;\n      span.end();\n\n      if (prevSpan) {\n        return withActiveSpan(prevSpan, () => {\n          return Reflect.apply(originalNext, thisArgNext, argsNext);\n        });\n      }\n\n      return Reflect.apply(originalNext, thisArgNext, argsNext);\n    },\n  });\n}\n\n/**\n * Wraps a TanStack Start middleware with Sentry instrumentation to create spans.\n */\nfunction wrapMiddlewareWithSentry<T extends TanStackMiddlewareBase>(\n  middleware: T,\n  options: MiddlewareWrapperOptions,\n): T {\n  if (\n    (middleware as TanStackMiddlewareBase & { [SENTRY_WRAPPED]?: boolean })[SENTRY_WRAPPED] ||\n    (middleware as TanStackMiddlewareBase & { [SENTRY_INTERNAL]?: boolean })[SENTRY_INTERNAL]\n  ) {\n    // already instrumented or internal Sentry middleware\n    return middleware;\n  }\n\n  // instrument server middleware\n  if (middleware.options?.server) {\n    middleware.options.server = new Proxy(middleware.options.server, {\n      apply: (originalServer, thisArgServer, argsServer) => {\n        const prevSpan = getActiveSpan();\n\n        return startSpanManual(getMiddlewareSpanOptions(options.name), async (span: Span) => {\n          const nextState = { called: false };\n\n          // The server function receives { next, context, request } as first argument\n          // Users call next() inside their middleware to move down the middleware chain. We proxy next() to end the span when it is called.\n          const middlewareArgs = argsServer[0] as { next?: (...args: unknown[]) => unknown } | undefined;\n          if (middlewareArgs && typeof middlewareArgs === 'object' && typeof middlewareArgs.next === 'function') {\n            middlewareArgs.next = getNextProxy(middlewareArgs.next, span, prevSpan, nextState);\n          }\n\n          try {\n            const result = await originalServer.apply(thisArgServer, argsServer);\n\n            // End span here if next() wasn't called, else we already ended it in next()\n            if (!nextState.called) {\n              span.end();\n            }\n\n            return result;\n          } catch (e) {\n            span.end();\n            throw e;\n          }\n        });\n      },\n    });\n\n    // mark as instrumented\n    addNonEnumerableProperty(middleware as unknown as Record<string, unknown>, SENTRY_WRAPPED, true);\n  }\n\n  return middleware;\n}\n\n/**\n * Wraps multiple TanStack Start middlewares with Sentry instrumentation.\n * Object keys are used as span names to avoid users having to specify this manually.\n *\n * @example\n * ```ts\n * import { wrapMiddlewaresWithSentry } from '@sentry/tanstackstart-react';\n *\n * const wrappedMiddlewares = wrapMiddlewaresWithSentry({\n *   authMiddleware,\n *   loggingMiddleware,\n * });\n *\n * createServerFn().middleware(wrappedMiddlewares)\n * ```\n *\n * @param middlewares - An object containing middlewares\n * @returns An array of wrapped middlewares\n */\nexport function wrapMiddlewaresWithSentry<T extends TanStackMiddlewareBase>(middlewares: Record<string, T>): T[] {\n  return Object.entries(middlewares).map(([name, middleware]) => {\n    return wrapMiddlewareWithSentry(middleware, { name });\n  });\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"middleware.js","sources":["../../../src/server/middleware.ts"],"sourcesContent":["import { addNonEnumerableProperty } from '@sentry/core';\nimport type { Span } from '@sentry/node';\nimport { getActiveSpan, startSpanManual, withActiveSpan } from '@sentry/node';\nimport type { MiddlewareWrapperOptions, TanStackMiddlewareBase } from '../common/types';\nimport { getMiddlewareSpanOptions } from './utils';\n\nconst SENTRY_WRAPPED = '__SENTRY_WRAPPED__';\nexport const SENTRY_INTERNAL = '__SENTRY_INTERNAL__';\n\n/**\n * Creates a proxy for the next function that ends the current span and restores the parent span.\n * This ensures that subsequent middleware spans are children of the root span, not nested children.\n */\nfunction getNextProxy<T extends (...args: unknown[]) => unknown>(\n  next: T,\n  span: Span,\n  prevSpan: Span | undefined,\n  nextState: { called: boolean },\n): T {\n  return new Proxy(next, {\n    apply: (originalNext, thisArgNext, argsNext) => {\n      nextState.called = true;\n      span.end();\n\n      if (prevSpan) {\n        return withActiveSpan(prevSpan, () => {\n          return Reflect.apply(originalNext, thisArgNext, argsNext);\n        });\n      }\n\n      return Reflect.apply(originalNext, thisArgNext, argsNext);\n    },\n  });\n}\n\n/**\n * Wraps a TanStack Start middleware with Sentry instrumentation to create spans.\n */\nfunction wrapMiddlewareWithSentry<T extends TanStackMiddlewareBase>(\n  middleware: T,\n  options: MiddlewareWrapperOptions,\n): T {\n  if (\n    (middleware as TanStackMiddlewareBase & { [SENTRY_WRAPPED]?: boolean })[SENTRY_WRAPPED] ||\n    (middleware as TanStackMiddlewareBase & { [SENTRY_INTERNAL]?: boolean })[SENTRY_INTERNAL]\n  ) {\n    // already instrumented or internal Sentry middleware\n    return middleware;\n  }\n\n  // instrument server middleware\n  if (middleware.options?.server) {\n    middleware.options.server = new Proxy(middleware.options.server, {\n      apply: (originalServer, thisArgServer, argsServer) => {\n        const prevSpan = getActiveSpan();\n\n        return startSpanManual(getMiddlewareSpanOptions(options.name), async (span: Span) => {\n          const nextState = { called: false };\n\n          // The server function receives { next, context, request } as first argument\n          // Users call next() inside their middleware to move down the middleware chain. We proxy next() to end the span when it is called.\n          const middlewareArgs = argsServer[0] as { next?: (...args: unknown[]) => unknown } | undefined;\n          if (middlewareArgs && typeof middlewareArgs === 'object' && typeof middlewareArgs.next === 'function') {\n            middlewareArgs.next = getNextProxy(middlewareArgs.next, span, prevSpan, nextState);\n          }\n\n          try {\n            const result = await originalServer.apply(thisArgServer, argsServer);\n\n            // End span here if next() wasn't called, else we already ended it in next()\n            if (!nextState.called) {\n              span.end();\n            }\n\n            return result;\n          } catch (e) {\n            span.end();\n            throw e;\n          }\n        });\n      },\n    });\n\n    // mark as instrumented\n    addNonEnumerableProperty(middleware as unknown as Record<string, unknown>, SENTRY_WRAPPED, true);\n  }\n\n  return middleware;\n}\n\n/**\n * Wraps multiple TanStack Start middlewares with Sentry instrumentation.\n * Object keys are used as span names to avoid users having to specify this manually.\n *\n * @example\n * ```ts\n * import { wrapMiddlewaresWithSentry } from '@sentry/tanstackstart-react';\n *\n * const wrappedMiddlewares = wrapMiddlewaresWithSentry({\n *   authMiddleware,\n *   loggingMiddleware,\n * });\n *\n * createServerFn().middleware(wrappedMiddlewares)\n * ```\n *\n * @param middlewares - An object containing middlewares\n * @returns An array of wrapped middlewares\n */\nexport function wrapMiddlewaresWithSentry<T extends TanStackMiddlewareBase>(middlewares: Record<string, T>): T[] {\n  return Object.entries(middlewares).map(([name, middleware]) => {\n    return wrapMiddlewareWithSentry(middleware, { name });\n  });\n}\n"],"names":[],"mappings":";;;;AAMA,MAAM,cAAA,GAAiB,oBAAA;AAChB,MAAM,eAAA,GAAkB;AAM/B,SAAS,YAAA,CACP,IAAA,EACA,IAAA,EACA,QAAA,EACA,SAAA,EACG;AACH,EAAA,OAAO,IAAI,MAAM,IAAA,EAAM;AAAA,IACrB,KAAA,EAAO,CAAC,YAAA,EAAc,WAAA,EAAa,QAAA,KAAa;AAC9C,MAAA,SAAA,CAAU,MAAA,GAAS,IAAA;AACnB,MAAA,IAAA,CAAK,GAAA,EAAI;AAET,MAAA,IAAI,QAAA,EAAU;AACZ,QAAA,OAAO,cAAA,CAAe,UAAU,MAAM;AACpC,UAAA,OAAO,OAAA,CAAQ,KAAA,CAAM,YAAA,EAAc,WAAA,EAAa,QAAQ,CAAA;AAAA,QAC1D,CAAC,CAAA;AAAA,MACH;AAEA,MAAA,OAAO,OAAA,CAAQ,KAAA,CAAM,YAAA,EAAc,WAAA,EAAa,QAAQ,CAAA;AAAA,IAC1D;AAAA,GACD,CAAA;AACH;AAKA,SAAS,wBAAA,CACP,YACA,OAAA,EACG;AACH,EAAA,IACG,UAAA,CAAuE,cAAc,CAAA,IACrF,UAAA,CAAwE,eAAe,CAAA,EACxF;AAEA,IAAA,OAAO,UAAA;AAAA,EACT;AAGA,EAAA,IAAI,UAAA,CAAW,SAAS,MAAA,EAAQ;AAC9B,IAAA,UAAA,CAAW,QAAQ,MAAA,GAAS,IAAI,KAAA,CAAM,UAAA,CAAW,QAAQ,MAAA,EAAQ;AAAA,MAC/D,KAAA,EAAO,CAAC,cAAA,EAAgB,aAAA,EAAe,UAAA,KAAe;AACpD,QAAA,MAAM,WAAW,aAAA,EAAc;AAE/B,QAAA,OAAO,gBAAgB,wBAAA,CAAyB,OAAA,CAAQ,IAAI,CAAA,EAAG,OAAO,IAAA,KAAe;AACnF,UAAA,MAAM,SAAA,GAAY,EAAE,MAAA,EAAQ,KAAA,EAAM;AAIlC,UAAA,MAAM,cAAA,GAAiB,WAAW,CAAC,CAAA;AACnC,UAAA,IAAI,kBAAkB,OAAO,cAAA,KAAmB,YAAY,OAAO,cAAA,CAAe,SAAS,UAAA,EAAY;AACrG,YAAA,cAAA,CAAe,OAAO,YAAA,CAAa,cAAA,CAAe,IAAA,EAAM,IAAA,EAAM,UAAU,SAAS,CAAA;AAAA,UACnF;AAEA,UAAA,IAAI;AACF,YAAA,MAAM,MAAA,GAAS,MAAM,cAAA,CAAe,KAAA,CAAM,eAAe,UAAU,CAAA;AAGnE,YAAA,IAAI,CAAC,UAAU,MAAA,EAAQ;AACrB,cAAA,IAAA,CAAK,GAAA,EAAI;AAAA,YACX;AAEA,YAAA,OAAO,MAAA;AAAA,UACT,SAAS,CAAA,EAAG;AACV,YAAA,IAAA,CAAK,GAAA,EAAI;AACT,YAAA,MAAM,CAAA;AAAA,UACR;AAAA,QACF,CAAC,CAAA;AAAA,MACH;AAAA,KACD,CAAA;AAGD,IAAA,wBAAA,CAAyB,UAAA,EAAkD,gBAAgB,IAAI,CAAA;AAAA,EACjG;AAEA,EAAA,OAAO,UAAA;AACT;AAqBO,SAAS,0BAA4D,WAAA,EAAqC;AAC/G,EAAA,OAAO,MAAA,CAAO,QAAQ,WAAW,CAAA,CAAE,IAAI,CAAC,CAAC,IAAA,EAAM,UAAU,CAAA,KAAM;AAC7D,IAAA,OAAO,wBAAA,CAAyB,UAAA,EAAY,EAAE,IAAA,EAAM,CAAA;AAAA,EACtD,CAAC,CAAA;AACH;;;;"}

package/build/esm/server/sdk.js

@@ -1,17 +1,12 @@
 import { applySdkMetadata } from '@sentry/core';
 import { getDefaultIntegrations, init as init$1 } from '@sentry/node';
 
-/**
- * Initializes the server side of the TanStack Start React SDK
- */
 function init(options) {
   const sentryOptions = {
     defaultIntegrations: [...getDefaultIntegrations(options)],
-    ...options,
+    ...options
   };
-
-  applySdkMetadata(sentryOptions, 'tanstackstart-react', ['tanstackstart-react', 'node']);
-
+  applySdkMetadata(sentryOptions, "tanstackstart-react", ["tanstackstart-react", "node"]);
   return init$1(sentryOptions);
 }
 

package/build/esm/server/sdk.js.map

@@ -1 +1 @@
-{"version":3,"file":"sdk.js","sources":["../../../src/server/sdk.ts"],"sourcesContent":["import { applySdkMetadata } from '@sentry/core';\nimport type { NodeClient, NodeOptions } from '@sentry/node';\nimport { getDefaultIntegrations as getDefaultNodeIntegrations, init as initNodeSdk } from '@sentry/node';\n\n/**\n * Initializes the server side of the TanStack Start React SDK\n */\nexport function init(options: NodeOptions): NodeClient | undefined {\n  const sentryOptions: NodeOptions = {\n    defaultIntegrations: [...getDefaultNodeIntegrations(options)],\n    ...options,\n  };\n\n  applySdkMetadata(sentryOptions, 'tanstackstart-react', ['tanstackstart-react', 'node']);\n\n  return initNodeSdk(sentryOptions);\n}\n"],"names":["getDefaultNodeIntegrations","initNodeSdk"],"mappings":";;;AAIA;AACA;AACA;AACO,SAAS,IAAI,CAAC,OAAO,EAAuC;AACnE,EAAE,MAAM,aAAa,GAAgB;AACrC,IAAI,mBAAmB,EAAE,CAAC,GAAGA,sBAA0B,CAAC,OAAO,CAAC,CAAC;AACjE,IAAI,GAAG,OAAO;AACd,GAAG;;AAEH,EAAE,gBAAgB,CAAC,aAAa,EAAE,qBAAqB,EAAE,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAC;;AAEzF,EAAE,OAAOC,MAAW,CAAC,aAAa,CAAC;AACnC;;;;"}
+{"version":3,"file":"sdk.js","sources":["../../../src/server/sdk.ts"],"sourcesContent":["import { applySdkMetadata } from '@sentry/core';\nimport type { NodeClient, NodeOptions } from '@sentry/node';\nimport { getDefaultIntegrations as getDefaultNodeIntegrations, init as initNodeSdk } from '@sentry/node';\n\n/**\n * Initializes the server side of the TanStack Start React SDK\n */\nexport function init(options: NodeOptions): NodeClient | undefined {\n  const sentryOptions: NodeOptions = {\n    defaultIntegrations: [...getDefaultNodeIntegrations(options)],\n    ...options,\n  };\n\n  applySdkMetadata(sentryOptions, 'tanstackstart-react', ['tanstackstart-react', 'node']);\n\n  return initNodeSdk(sentryOptions);\n}\n"],"names":["getDefaultNodeIntegrations","initNodeSdk"],"mappings":";;;AAOO,SAAS,KAAK,OAAA,EAA8C;AACjE,EAAA,MAAM,aAAA,GAA6B;AAAA,IACjC,mBAAA,EAAqB,CAAC,GAAGA,sBAAA,CAA2B,OAAO,CAAC,CAAA;AAAA,IAC5D,GAAG;AAAA,GACL;AAEA,EAAA,gBAAA,CAAiB,aAAA,EAAe,qBAAA,EAAuB,CAAC,qBAAA,EAAuB,MAAM,CAAC,CAAA;AAEtF,EAAA,OAAOC,OAAY,aAAa,CAAA;AAClC;;;;"}

package/build/esm/server/tunnelRoute.js

@@ -1,47 +1,27 @@
 import { getClient, dsnToString, handleTunnelRequest } from '@sentry/core';
 
-/**
- * Creates a TanStack Start server route configuration for tunneling Sentry envelopes.
- *
- * @example
- * ```ts
- * import { createFileRoute } from '@tanstack/react-router';
- * import * as Sentry from '@sentry/tanstackstart-react';
- *
- * export const Route = createFileRoute('/monitoring')({
- *   server: Sentry.createSentryTunnelRoute({
- *     allowedDsns: ['https://public@o0.ingest.sentry.io/0'],
- *   }),
- * });
- * ```
- */
 function createSentryTunnelRoute(options) {
   return {
     handlers: {
       POST: async ({ request }) => {
-        const allowedDsnsFromOptions = options.allowedDsns?.length ? options.allowedDsns : undefined;
-
-        const allowedDsns =
-          allowedDsnsFromOptions ??
-          (() => {
-            const client = getClient();
-            const dsn = client?.getDsn();
-            return dsn ? [dsnToString(dsn)] : undefined;
-          })();
-
+        const allowedDsnsFromOptions = options.allowedDsns?.length ? options.allowedDsns : void 0;
+        const allowedDsns = allowedDsnsFromOptions ?? (() => {
+          const client = getClient();
+          const dsn = client?.getDsn();
+          return dsn ? [dsnToString(dsn)] : void 0;
+        })();
         if (!allowedDsns) {
           return new Response(
-            'Tunnel route requires Sentry server SDK initialized with a DSN, or pass allowedDsns explicitly.',
-            { status: 500 },
+            "Tunnel route requires Sentry server SDK initialized with a DSN, or pass allowedDsns explicitly.",
+            { status: 500 }
           );
         }
-
         return handleTunnelRequest({
           request,
-          allowedDsns,
+          allowedDsns
         });
-      },
-    },
+      }
+    }
   };
 }
 

package/build/esm/server/tunnelRoute.js.map

@@ -1 +1 @@
-{"version":3,"file":"tunnelRoute.js","sources":["../../../src/server/tunnelRoute.ts"],"sourcesContent":["import { dsnToString, getClient, handleTunnelRequest } from '@sentry/core';\n\nexport interface CreateSentryTunnelRouteOptions {\n  allowedDsns?: string[];\n}\n\ntype SentryTunnelRouteHandlerContext = {\n  request: Request;\n};\n\ntype SentryTunnelRoute = {\n  handlers: {\n    POST: (context: SentryTunnelRouteHandlerContext) => Promise<Response>;\n  };\n};\n\n/**\n * Creates a TanStack Start server route configuration for tunneling Sentry envelopes.\n *\n * @example\n * ```ts\n * import { createFileRoute } from '@tanstack/react-router';\n * import * as Sentry from '@sentry/tanstackstart-react';\n *\n * export const Route = createFileRoute('/monitoring')({\n *   server: Sentry.createSentryTunnelRoute({\n *     allowedDsns: ['https://public@o0.ingest.sentry.io/0'],\n *   }),\n * });\n * ```\n */\nexport function createSentryTunnelRoute(options: CreateSentryTunnelRouteOptions): SentryTunnelRoute {\n  return {\n    handlers: {\n      POST: async ({ request }) => {\n        const allowedDsnsFromOptions = options.allowedDsns?.length ? options.allowedDsns : undefined;\n\n        const allowedDsns =\n          allowedDsnsFromOptions ??\n          (() => {\n            const client = getClient();\n            const dsn = client?.getDsn();\n            return dsn ? [dsnToString(dsn)] : undefined;\n          })();\n\n        if (!allowedDsns) {\n          return new Response(\n            'Tunnel route requires Sentry server SDK initialized with a DSN, or pass allowedDsns explicitly.',\n            { status: 500 },\n          );\n        }\n\n        return handleTunnelRequest({\n          request,\n          allowedDsns,\n        });\n      },\n    },\n  };\n}\n"],"names":[],"mappings":";;AAgBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,uBAAuB,CAAC,OAAO,EAAqD;AACpG,EAAE,OAAO;AACT,IAAI,QAAQ,EAAE;AACd,MAAM,IAAI,EAAE,OAAO,EAAE,OAAA,EAAS,KAAK;AACnC,QAAQ,MAAM,sBAAA,GAAyB,OAAO,CAAC,WAAW,EAAE,MAAA,GAAS,OAAO,CAAC,WAAA,GAAc,SAAS;;AAEpG,QAAQ,MAAM,WAAA;AACd,UAAU,sBAAA;AACV,UAAU,CAAC,MAAM;AACjB,YAAY,MAAM,MAAA,GAAS,SAAS,EAAE;AACtC,YAAY,MAAM,GAAA,GAAM,MAAM,EAAE,MAAM,EAAE;AACxC,YAAY,OAAO,GAAA,GAAM,CAAC,WAAW,CAAC,GAAG,CAAC,CAAA,GAAI,SAAS;AACvD,UAAU,CAAC,GAAG;;AAEd,QAAQ,IAAI,CAAC,WAAW,EAAE;AAC1B,UAAU,OAAO,IAAI,QAAQ;AAC7B,YAAY,iGAAiG;AAC7G,YAAY,EAAE,MAAM,EAAE,GAAA,EAAK;AAC3B,WAAW;AACX,QAAQ;;AAER,QAAQ,OAAO,mBAAmB,CAAC;AACnC,UAAU,OAAO;AACjB,UAAU,WAAW;AACrB,SAAS,CAAC;AACV,MAAM,CAAC;AACP,KAAK;AACL,GAAG;AACH;;;;"}
+{"version":3,"file":"tunnelRoute.js","sources":["../../../src/server/tunnelRoute.ts"],"sourcesContent":["import { dsnToString, getClient, handleTunnelRequest } from '@sentry/core';\n\nexport interface CreateSentryTunnelRouteOptions {\n  allowedDsns?: string[];\n}\n\ntype SentryTunnelRouteHandlerContext = {\n  request: Request;\n};\n\ntype SentryTunnelRoute = {\n  handlers: {\n    POST: (context: SentryTunnelRouteHandlerContext) => Promise<Response>;\n  };\n};\n\n/**\n * Creates a TanStack Start server route configuration for tunneling Sentry envelopes.\n *\n * @example\n * ```ts\n * import { createFileRoute } from '@tanstack/react-router';\n * import * as Sentry from '@sentry/tanstackstart-react';\n *\n * export const Route = createFileRoute('/monitoring')({\n *   server: Sentry.createSentryTunnelRoute({\n *     allowedDsns: ['https://public@o0.ingest.sentry.io/0'],\n *   }),\n * });\n * ```\n */\nexport function createSentryTunnelRoute(options: CreateSentryTunnelRouteOptions): SentryTunnelRoute {\n  return {\n    handlers: {\n      POST: async ({ request }) => {\n        const allowedDsnsFromOptions = options.allowedDsns?.length ? options.allowedDsns : undefined;\n\n        const allowedDsns =\n          allowedDsnsFromOptions ??\n          (() => {\n            const client = getClient();\n            const dsn = client?.getDsn();\n            return dsn ? [dsnToString(dsn)] : undefined;\n          })();\n\n        if (!allowedDsns) {\n          return new Response(\n            'Tunnel route requires Sentry server SDK initialized with a DSN, or pass allowedDsns explicitly.',\n            { status: 500 },\n          );\n        }\n\n        return handleTunnelRequest({\n          request,\n          allowedDsns,\n        });\n      },\n    },\n  };\n}\n"],"names":[],"mappings":";;AA+BO,SAAS,wBAAwB,OAAA,EAA4D;AAClG,EAAA,OAAO;AAAA,IACL,QAAA,EAAU;AAAA,MACR,IAAA,EAAM,OAAO,EAAE,OAAA,EAAQ,KAAM;AAC3B,QAAA,MAAM,sBAAA,GAAyB,OAAA,CAAQ,WAAA,EAAa,MAAA,GAAS,QAAQ,WAAA,GAAc,MAAA;AAEnF,QAAA,MAAM,WAAA,GACJ,2BACC,MAAM;AACL,UAAA,MAAM,SAAS,SAAA,EAAU;AACzB,UAAA,MAAM,GAAA,GAAM,QAAQ,MAAA,EAAO;AAC3B,UAAA,OAAO,GAAA,GAAM,CAAC,WAAA,CAAY,GAAG,CAAC,CAAA,GAAI,MAAA;AAAA,QACpC,CAAA,GAAG;AAEL,QAAA,IAAI,CAAC,WAAA,EAAa;AAChB,UAAA,OAAO,IAAI,QAAA;AAAA,YACT,iGAAA;AAAA,YACA,EAAE,QAAQ,GAAA;AAAI,WAChB;AAAA,QACF;AAEA,QAAA,OAAO,mBAAA,CAAoB;AAAA,UACzB,OAAA;AAAA,UACA;AAAA,SACD,CAAA;AAAA,MACH;AAAA;AACF,GACF;AACF;;;;"}

package/build/esm/server/utils.js

@@ -1,29 +1,17 @@
 import { SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '@sentry/node';
 
-/**
- * Extracts the SHA-256 hash from a server function pathname.
- * Server function pathnames are structured as `/_serverFn/<hash>`.
- * This function matches the pattern and returns the hash if found.
- *
- * @param pathname - the pathname of the server function
- * @returns the sha256 of the server function
- */
 function extractServerFunctionSha256(pathname) {
   const serverFnMatch = pathname.match(/\/_serverFn\/([a-f0-9]{64})/i);
-  return serverFnMatch?.[1] ?? 'unknown';
+  return serverFnMatch?.[1] ?? "unknown";
 }
-
-/**
- * Returns span options for TanStack Start middleware spans.
- */
 function getMiddlewareSpanOptions(name) {
   return {
-    op: 'middleware.tanstackstart',
+    op: "middleware.tanstackstart",
     name,
     attributes: {
-      [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.middleware.tanstackstart',
-      [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'middleware.tanstackstart',
-    },
+      [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.middleware.tanstackstart",
+      [SEMANTIC_ATTRIBUTE_SENTRY_OP]: "middleware.tanstackstart"
+    }
   };
 }
 

package/build/esm/server/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","sources":["../../../src/server/utils.ts"],"sourcesContent":["import type { StartSpanOptions } from '@sentry/core';\nimport { SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '@sentry/node';\n\n/**\n * Extracts the SHA-256 hash from a server function pathname.\n * Server function pathnames are structured as `/_serverFn/<hash>`.\n * This function matches the pattern and returns the hash if found.\n *\n * @param pathname - the pathname of the server function\n * @returns the sha256 of the server function\n */\nexport function extractServerFunctionSha256(pathname: string): string {\n  const serverFnMatch = pathname.match(/\\/_serverFn\\/([a-f0-9]{64})/i);\n  return serverFnMatch?.[1] ?? 'unknown';\n}\n\n/**\n * Returns span options for TanStack Start middleware spans.\n */\nexport function getMiddlewareSpanOptions(name: string): StartSpanOptions {\n  return {\n    op: 'middleware.tanstackstart',\n    name,\n    attributes: {\n      [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.middleware.tanstackstart',\n      [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'middleware.tanstackstart',\n    },\n  };\n}\n"],"names":[],"mappings":";;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,2BAA2B,CAAC,QAAQ,EAAkB;AACtE,EAAE,MAAM,gBAAgB,QAAQ,CAAC,KAAK,CAAC,8BAA8B,CAAC;AACtE,EAAE,OAAO,aAAa,GAAG,CAAC,CAAA,IAAK,SAAS;AACxC;;AAEA;AACA;AACA;AACO,SAAS,wBAAwB,CAAC,IAAI,EAA4B;AACzE,EAAE,OAAO;AACT,IAAI,EAAE,EAAE,0BAA0B;AAClC,IAAI,IAAI;AACR,IAAI,UAAU,EAAE;AAChB,MAAM,CAAC,gCAAgC,GAAG,+BAA+B;AACzE,MAAM,CAAC,4BAA4B,GAAG,0BAA0B;AAChE,KAAK;AACL,GAAG;AACH;;;;"}
+{"version":3,"file":"utils.js","sources":["../../../src/server/utils.ts"],"sourcesContent":["import type { StartSpanOptions } from '@sentry/core';\nimport { SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '@sentry/node';\n\n/**\n * Extracts the SHA-256 hash from a server function pathname.\n * Server function pathnames are structured as `/_serverFn/<hash>`.\n * This function matches the pattern and returns the hash if found.\n *\n * @param pathname - the pathname of the server function\n * @returns the sha256 of the server function\n */\nexport function extractServerFunctionSha256(pathname: string): string {\n  const serverFnMatch = pathname.match(/\\/_serverFn\\/([a-f0-9]{64})/i);\n  return serverFnMatch?.[1] ?? 'unknown';\n}\n\n/**\n * Returns span options for TanStack Start middleware spans.\n */\nexport function getMiddlewareSpanOptions(name: string): StartSpanOptions {\n  return {\n    op: 'middleware.tanstackstart',\n    name,\n    attributes: {\n      [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.middleware.tanstackstart',\n      [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'middleware.tanstackstart',\n    },\n  };\n}\n"],"names":[],"mappings":";;AAWO,SAAS,4BAA4B,QAAA,EAA0B;AACpE,EAAA,MAAM,aAAA,GAAgB,QAAA,CAAS,KAAA,CAAM,8BAA8B,CAAA;AACnE,EAAA,OAAO,aAAA,GAAgB,CAAC,CAAA,IAAK,SAAA;AAC/B;AAKO,SAAS,yBAAyB,IAAA,EAAgC;AACvE,EAAA,OAAO;AAAA,IACL,EAAA,EAAI,0BAAA;AAAA,IACJ,IAAA;AAAA,IACA,UAAA,EAAY;AAAA,MACV,CAAC,gCAAgC,GAAG,+BAAA;AAAA,MACpC,CAAC,4BAA4B,GAAG;AAAA;AAClC,GACF;AACF;;;;"}

package/build/esm/server/wrapFetchWithSentry.js

@@ -2,30 +2,6 @@ import { flushIfServerless } from '@sentry/core';
 import { SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, startSpan } from '@sentry/node';
 import { extractServerFunctionSha256 } from './utils.js';
 
-/**
- * This function can be used to wrap the server entry request handler to add tracing to server-side functionality.
- * You must explicitly define a server entry point in your application for this to work. This is done by passing the request handler to the `createServerEntry` function.
- * For more information about the server entry point, see the [TanStack Start documentation](https://tanstack.com/start/docs/server-entry).
- *
- * @example
- * ```ts
- * import { wrapFetchWithSentry } from '@sentry/tanstackstart-react';
- *
- * import handler, { createServerEntry } from '@tanstack/react-start/server-entry';
- * import type { ServerEntry } from '@tanstack/react-start/server-entry';
- *
- * const requestHandler: ServerEntry = wrapFetchWithSentry({
- *  fetch(request: Request) {
- *    return handler.fetch(request);
- *  },
- * });
- *
- * export default serverEntry = createServerEntry(requestHandler);
- * ```
- *
- * @param serverEntry - request handler to wrap
- * @returns - wrapped request handler
- */
 function wrapFetchWithSentry(serverEntry) {
   if (serverEntry.fetch) {
     serverEntry.fetch = new Proxy(serverEntry.fetch, {
@@ -33,36 +9,31 @@ function wrapFetchWithSentry(serverEntry) {
         try {
           const request = args[0];
           const url = new URL(request.url);
-          const method = request.method || 'GET';
-
-          // instrument server functions
-          if (url.pathname.includes('_serverFn') || url.pathname.includes('createServerFn')) {
+          const method = request.method || "GET";
+          if (url.pathname.includes("_serverFn") || url.pathname.includes("createServerFn")) {
             const functionSha256 = extractServerFunctionSha256(url.pathname);
-            const op = 'function.tanstackstart';
-
+            const op = "function.tanstackstart";
             const serverFunctionSpanAttributes = {
-              [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.function.tanstackstart.server',
+              [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.function.tanstackstart.server",
               [SEMANTIC_ATTRIBUTE_SENTRY_OP]: op,
-              'tanstackstart.function.hash.sha256': functionSha256,
+              "tanstackstart.function.hash.sha256": functionSha256
             };
-
             return await startSpan(
               {
-                op: op,
+                op,
                 name: `${method} ${url.pathname}`,
-                attributes: serverFunctionSpanAttributes,
+                attributes: serverFunctionSpanAttributes
               },
               async () => {
                 return target.apply(thisArg, args);
-              },
+              }
             );
           }
-
           return await target.apply(thisArg, args);
         } finally {
           await flushIfServerless();
         }
-      },
+      }
     });
   }
   return serverEntry;

package/build/esm/server/wrapFetchWithSentry.js.map

@@ -1 +1 @@
-{"version":3,"file":"wrapFetchWithSentry.js","sources":["../../../src/server/wrapFetchWithSentry.ts"],"sourcesContent":["import { flushIfServerless } from '@sentry/core';\nimport { SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, startSpan } from '@sentry/node';\nimport { extractServerFunctionSha256 } from './utils';\n\nexport type ServerEntry = {\n  fetch: (request: Request, opts?: unknown) => Promise<Response> | Response;\n};\n\n/**\n * This function can be used to wrap the server entry request handler to add tracing to server-side functionality.\n * You must explicitly define a server entry point in your application for this to work. This is done by passing the request handler to the `createServerEntry` function.\n * For more information about the server entry point, see the [TanStack Start documentation](https://tanstack.com/start/docs/server-entry).\n *\n * @example\n * ```ts\n * import { wrapFetchWithSentry } from '@sentry/tanstackstart-react';\n *\n * import handler, { createServerEntry } from '@tanstack/react-start/server-entry';\n * import type { ServerEntry } from '@tanstack/react-start/server-entry';\n *\n * const requestHandler: ServerEntry = wrapFetchWithSentry({\n *  fetch(request: Request) {\n *    return handler.fetch(request);\n *  },\n * });\n *\n * export default serverEntry = createServerEntry(requestHandler);\n * ```\n *\n * @param serverEntry - request handler to wrap\n * @returns - wrapped request handler\n */\nexport function wrapFetchWithSentry(serverEntry: ServerEntry): ServerEntry {\n  if (serverEntry.fetch) {\n    serverEntry.fetch = new Proxy<typeof serverEntry.fetch>(serverEntry.fetch, {\n      async apply(target, thisArg, args) {\n        try {\n          const request: Request = args[0];\n          const url = new URL(request.url);\n          const method = request.method || 'GET';\n\n          // instrument server functions\n          if (url.pathname.includes('_serverFn') || url.pathname.includes('createServerFn')) {\n            const functionSha256 = extractServerFunctionSha256(url.pathname);\n            const op = 'function.tanstackstart';\n\n            const serverFunctionSpanAttributes = {\n              [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.function.tanstackstart.server',\n              [SEMANTIC_ATTRIBUTE_SENTRY_OP]: op,\n              'tanstackstart.function.hash.sha256': functionSha256,\n            };\n\n            return await startSpan(\n              {\n                op: op,\n                name: `${method} ${url.pathname}`,\n                attributes: serverFunctionSpanAttributes,\n              },\n              async () => {\n                return target.apply(thisArg, args);\n              },\n            );\n          }\n\n          return await target.apply(thisArg, args);\n        } finally {\n          await flushIfServerless();\n        }\n      },\n    });\n  }\n  return serverEntry;\n}\n"],"names":[],"mappings":";;;;AAQA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,mBAAmB,CAAC,WAAW,EAA4B;AAC3E,EAAE,IAAI,WAAW,CAAC,KAAK,EAAE;AACzB,IAAI,WAAW,CAAC,KAAA,GAAQ,IAAI,KAAK,CAA2B,WAAW,CAAC,KAAK,EAAE;AAC/E,MAAM,MAAM,KAAK,CAAC,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE;AACzC,QAAQ,IAAI;AACZ,UAAU,MAAM,OAAO,GAAY,IAAI,CAAC,CAAC,CAAC;AAC1C,UAAU,MAAM,MAAM,IAAI,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC;AAC1C,UAAU,MAAM,MAAA,GAAS,OAAO,CAAC,MAAA,IAAU,KAAK;;AAEhD;AACA,UAAU,IAAI,GAAG,CAAC,QAAQ,CAAC,QAAQ,CAAC,WAAW,KAAK,GAAG,CAAC,QAAQ,CAAC,QAAQ,CAAC,gBAAgB,CAAC,EAAE;AAC7F,YAAY,MAAM,iBAAiB,2BAA2B,CAAC,GAAG,CAAC,QAAQ,CAAC;AAC5E,YAAY,MAAM,EAAA,GAAK,wBAAwB;;AAE/C,YAAY,MAAM,+BAA+B;AACjD,cAAc,CAAC,gCAAgC,GAAG,oCAAoC;AACtF,cAAc,CAAC,4BAA4B,GAAG,EAAE;AAChD,cAAc,oCAAoC,EAAE,cAAc;AAClE,aAAa;;AAEb,YAAY,OAAO,MAAM,SAAS;AAClC,cAAc;AACd,gBAAgB,EAAE,EAAE,EAAE;AACtB,gBAAgB,IAAI,EAAE,CAAC,EAAA,MAAA,CAAA,CAAA,EAAA,GAAA,CAAA,QAAA,CAAA,CAAA;AACA,gBAAA,UAAA,EAAA,4BAAA;AACA,eAAA;AACA,cAAA,YAAA;AACA,gBAAA,OAAA,MAAA,CAAA,KAAA,CAAA,OAAA,EAAA,IAAA,CAAA;AACA,cAAA,CAAA;AACA,aAAA;AACA,UAAA;;AAEA,UAAA,OAAA,MAAA,MAAA,CAAA,KAAA,CAAA,OAAA,EAAA,IAAA,CAAA;AACA,QAAA,CAAA,SAAA;AACA,UAAA,MAAA,iBAAA,EAAA;AACA,QAAA;AACA,MAAA,CAAA;AACA,KAAA,CAAA;AACA,EAAA;AACA,EAAA,OAAA,WAAA;AACA;;;;"}
+{"version":3,"file":"wrapFetchWithSentry.js","sources":["../../../src/server/wrapFetchWithSentry.ts"],"sourcesContent":["import { flushIfServerless } from '@sentry/core';\nimport { SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, startSpan } from '@sentry/node';\nimport { extractServerFunctionSha256 } from './utils';\n\nexport type ServerEntry = {\n  fetch: (request: Request, opts?: unknown) => Promise<Response> | Response;\n};\n\n/**\n * This function can be used to wrap the server entry request handler to add tracing to server-side functionality.\n * You must explicitly define a server entry point in your application for this to work. This is done by passing the request handler to the `createServerEntry` function.\n * For more information about the server entry point, see the [TanStack Start documentation](https://tanstack.com/start/docs/server-entry).\n *\n * @example\n * ```ts\n * import { wrapFetchWithSentry } from '@sentry/tanstackstart-react';\n *\n * import handler, { createServerEntry } from '@tanstack/react-start/server-entry';\n * import type { ServerEntry } from '@tanstack/react-start/server-entry';\n *\n * const requestHandler: ServerEntry = wrapFetchWithSentry({\n *  fetch(request: Request) {\n *    return handler.fetch(request);\n *  },\n * });\n *\n * export default serverEntry = createServerEntry(requestHandler);\n * ```\n *\n * @param serverEntry - request handler to wrap\n * @returns - wrapped request handler\n */\nexport function wrapFetchWithSentry(serverEntry: ServerEntry): ServerEntry {\n  if (serverEntry.fetch) {\n    serverEntry.fetch = new Proxy<typeof serverEntry.fetch>(serverEntry.fetch, {\n      async apply(target, thisArg, args) {\n        try {\n          const request: Request = args[0];\n          const url = new URL(request.url);\n          const method = request.method || 'GET';\n\n          // instrument server functions\n          if (url.pathname.includes('_serverFn') || url.pathname.includes('createServerFn')) {\n            const functionSha256 = extractServerFunctionSha256(url.pathname);\n            const op = 'function.tanstackstart';\n\n            const serverFunctionSpanAttributes = {\n              [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.function.tanstackstart.server',\n              [SEMANTIC_ATTRIBUTE_SENTRY_OP]: op,\n              'tanstackstart.function.hash.sha256': functionSha256,\n            };\n\n            return await startSpan(\n              {\n                op: op,\n                name: `${method} ${url.pathname}`,\n                attributes: serverFunctionSpanAttributes,\n              },\n              async () => {\n                return target.apply(thisArg, args);\n              },\n            );\n          }\n\n          return await target.apply(thisArg, args);\n        } finally {\n          await flushIfServerless();\n        }\n      },\n    });\n  }\n  return serverEntry;\n}\n"],"names":[],"mappings":";;;;AAgCO,SAAS,oBAAoB,WAAA,EAAuC;AACzE,EAAA,IAAI,YAAY,KAAA,EAAO;AACrB,IAAA,WAAA,CAAY,KAAA,GAAQ,IAAI,KAAA,CAAgC,WAAA,CAAY,KAAA,EAAO;AAAA,MACzE,MAAM,KAAA,CAAM,MAAA,EAAQ,OAAA,EAAS,IAAA,EAAM;AACjC,QAAA,IAAI;AACF,UAAA,MAAM,OAAA,GAAmB,KAAK,CAAC,CAAA;AAC/B,UAAA,MAAM,GAAA,GAAM,IAAI,GAAA,CAAI,OAAA,CAAQ,GAAG,CAAA;AAC/B,UAAA,MAAM,MAAA,GAAS,QAAQ,MAAA,IAAU,KAAA;AAGjC,UAAA,IAAI,GAAA,CAAI,SAAS,QAAA,CAAS,WAAW,KAAK,GAAA,CAAI,QAAA,CAAS,QAAA,CAAS,gBAAgB,CAAA,EAAG;AACjF,YAAA,MAAM,cAAA,GAAiB,2BAAA,CAA4B,GAAA,CAAI,QAAQ,CAAA;AAC/D,YAAA,MAAM,EAAA,GAAK,wBAAA;AAEX,YAAA,MAAM,4BAAA,GAA+B;AAAA,cACnC,CAAC,gCAAgC,GAAG,oCAAA;AAAA,cACpC,CAAC,4BAA4B,GAAG,EAAA;AAAA,cAChC,oCAAA,EAAsC;AAAA,aACxC;AAEA,YAAA,OAAO,MAAM,SAAA;AAAA,cACX;AAAA,gBACE,EAAA;AAAA,gBACA,IAAA,EAAM,CAAA,EAAG,MAAM,CAAA,CAAA,EAAI,IAAI,QAAQ,CAAA,CAAA;AAAA,gBAC/B,UAAA,EAAY;AAAA,eACd;AAAA,cACA,YAAY;AACV,gBAAA,OAAO,MAAA,CAAO,KAAA,CAAM,OAAA,EAAS,IAAI,CAAA;AAAA,cACnC;AAAA,aACF;AAAA,UACF;AAEA,UAAA,OAAO,MAAM,MAAA,CAAO,KAAA,CAAM,OAAA,EAAS,IAAI,CAAA;AAAA,QACzC,CAAA,SAAE;AACA,UAAA,MAAM,iBAAA,EAAkB;AAAA,QAC1B;AAAA,MACF;AAAA,KACD,CAAA;AAAA,EACH;AACA,EAAA,OAAO,WAAA;AACT;;;;"}

package/build/esm/vite/autoInstrumentMiddleware.js

@@ -1,116 +1,68 @@
-/**
- * Core function that wraps middleware arrays matching the given regex.
- */
 function wrapMiddlewareArrays(code, id, debug, regex) {
   const skipped = [];
   let didWrap = false;
-
   const transformed = code.replace(regex, (match, key, contents) => {
     const objContents = arrayToObjectShorthand(contents);
     if (objContents) {
       didWrap = true;
       if (debug) {
-        // eslint-disable-next-line no-console
         console.log(`[Sentry] Auto-wrapping ${key} in ${id}`);
       }
-      // Handle method call syntax like `.middleware([...])` vs object property syntax like `middleware: [...]`
-      if (key.endsWith('(')) {
+      if (key.endsWith("(")) {
         return `${key}wrapMiddlewaresWithSentry(${objContents}))`;
       }
       return `${key}: wrapMiddlewaresWithSentry(${objContents})`;
     }
-    // Track middlewares that couldn't be auto-wrapped
-    // Skip if we matched whitespace only
     if (contents.trim()) {
       skipped.push(key);
     }
     return match;
   });
-
   return { code: transformed, didWrap, skipped };
 }
-
-/**
- * Wraps global middleware arrays (requestMiddleware, functionMiddleware) in createStart() files.
- */
 function wrapGlobalMiddleware(code, id, debug) {
   return wrapMiddlewareArrays(code, id, debug, /(requestMiddleware|functionMiddleware)\s*:\s*\[([^\]]*)\]/g);
 }
-
-/**
- * Wraps route middleware arrays in createFileRoute() files.
- */
 function wrapRouteMiddleware(code, id, debug) {
   return wrapMiddlewareArrays(code, id, debug, /(middleware)\s*:\s*\[([^\]]*)\]/g);
 }
-
-/**
- * Wraps middleware arrays in createServerFn().middleware([...]) calls.
- */
 function wrapServerFnMiddleware(code, id, debug) {
   return wrapMiddlewareArrays(code, id, debug, /(\.middleware\s*\()\s*\[([^\]]*)\]\s*\)/g);
 }
-
-/**
- * Applies a wrap function to the current state and returns the updated state.
- */
-function applyWrap(
-  state,
-  wrapFn,
-  id,
-  debug,
-) {
+function applyWrap(state, wrapFn, id, debug) {
   const result = wrapFn(state.code, id, debug);
   return {
     code: result.code,
     needsImport: state.needsImport || result.didWrap,
-    skippedMiddlewares: [...state.skippedMiddlewares, ...result.skipped],
+    skippedMiddlewares: [...state.skippedMiddlewares, ...result.skipped]
   };
 }
-
-/**
- * A Vite plugin that automatically instruments TanStack Start middlewares:
- * - `requestMiddleware` and `functionMiddleware` arrays in `createStart()`
- * - `middleware` arrays in `createFileRoute()` route definitions
- */
 function makeAutoInstrumentMiddlewarePlugin(options = {}) {
   const { enabled = true, debug = false } = options;
-
   return {
-    name: 'sentry-tanstack-middleware-auto-instrument',
-    enforce: 'pre',
-
+    name: "sentry-tanstack-middleware-auto-instrument",
+    enforce: "pre",
     transform(code, id) {
       if (!enabled) {
         return null;
       }
-
-      // Skip if not a TS/JS file
       if (!/\.(ts|tsx|js|jsx|mjs|mts)$/.test(id)) {
         return null;
       }
-
-      // Detect file types that should be instrumented
-      const isStartFile = id.includes('start') && code.includes('createStart(');
-      const isRouteFile = code.includes('createFileRoute(') && /middleware\s*:\s*\[/.test(code);
-      const isServerFnFile = code.includes('createServerFn') && /\.middleware\s*\(\s*\[/.test(code);
-
+      const isStartFile = id.includes("start") && code.includes("createStart(");
+      const isRouteFile = code.includes("createFileRoute(") && /middleware\s*:\s*\[/.test(code);
+      const isServerFnFile = code.includes("createServerFn") && /\.middleware\s*\(\s*\[/.test(code);
       if (!isStartFile && !isRouteFile && !isServerFnFile) {
         return null;
       }
-
-      // Skip if the user already did some manual wrapping
-      if (code.includes('wrapMiddlewaresWithSentry')) {
+      if (code.includes("wrapMiddlewaresWithSentry")) {
         return null;
       }
-
       let fileTransformState = {
         code,
         needsImport: false,
-        skippedMiddlewares: [],
+        skippedMiddlewares: []
       };
-
-      // Wrap middlewares
       if (isStartFile) {
         fileTransformState = applyWrap(fileTransformState, wrapGlobalMiddleware, id, debug);
       }
@@ -120,70 +72,36 @@ function makeAutoInstrumentMiddlewarePlugin(options = {}) {
       if (isServerFnFile) {
         fileTransformState = applyWrap(fileTransformState, wrapServerFnMiddleware, id, debug);
       }
-
-      // Warn about middlewares that couldn't be auto-wrapped
       if (fileTransformState.skippedMiddlewares.length > 0) {
-        // eslint-disable-next-line no-console
         console.warn(
-          `[Sentry] Could not auto-instrument ${fileTransformState.skippedMiddlewares.join(' and ')} in ${id}. ` +
-            'To instrument these middlewares, use wrapMiddlewaresWithSentry() manually. ',
+          `[Sentry] Could not auto-instrument ${fileTransformState.skippedMiddlewares.join(" and ")} in ${id}. To instrument these middlewares, use wrapMiddlewaresWithSentry() manually. `
         );
       }
-
-      // We didn't wrap any middlewares, so we don't need to import the wrapMiddlewaresWithSentry function
       if (!fileTransformState.needsImport) {
         return null;
       }
-
       return { code: addSentryImport(fileTransformState.code), map: null };
-    },
+    }
   };
 }
-
-/**
- * Convert array contents to object shorthand syntax.
- * e.g., "foo, bar, baz" → "{ foo, bar, baz }"
- *
- * Returns null if contents contain non-identifier expressions (function calls, etc.)
- * which cannot be converted to object shorthand.
- */
 function arrayToObjectShorthand(contents) {
-  const items = contents
-    .split(',')
-    .map(s => s.trim())
-    .filter(Boolean);
-
-  // Only convert if all items are valid identifiers (no complex expressions)
-  const allIdentifiers = items.every(item => /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(item));
+  const items = contents.split(",").map((s) => s.trim()).filter(Boolean);
+  const allIdentifiers = items.every((item) => /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(item));
   if (!allIdentifiers || items.length === 0) {
     return null;
   }
-
-  // Deduplicate to avoid invalid syntax like { foo, foo }
   const uniqueItems = [...new Set(items)];
-
-  return `{ ${uniqueItems.join(', ')} }`;
+  return `{ ${uniqueItems.join(", ")} }`;
 }
-
-/**
- * Adds the wrapMiddlewaresWithSentry import to the code.
- * Handles 'use client' and 'use server' directives by inserting the import after them.
- */
 function addSentryImport(code) {
   const sentryImport = "import { wrapMiddlewaresWithSentry } from '@sentry/tanstackstart-react';\n";
-
-  // Don't add the import if it already exists
   if (code.includes(sentryImport.trimEnd())) {
     return code;
   }
-
-  // Check for 'use server' or 'use client' directives, these need to be before any imports
   const directiveMatch = code.match(/^(['"])use (client|server)\1;?\s*\n?/);
-
   if (!directiveMatch) {
     return sentryImport + code;
   }
-
   const directive = directiveMatch[0];
   return directive + sentryImport + code.slice(directive.length);
 }