From 224d8532c3cabd5dcaed5e135e664017500f5b0d Mon Sep 17 00:00:00 2001 From: Abdelrahman Awad Date: Mon, 23 Feb 2026 16:10:16 -0500 Subject: [PATCH 1/4] chore: draft --- packages/bun/src/index.ts | 2 + .../node-core/src/utils/ensureIsWrapped.ts | 2 +- packages/node/src/index.ts | 1 + .../src/integrations/tracing/elysia/index.ts | 138 ++++++++++++++++++ .../src/integrations/tracing/elysia/types.ts | 88 +++++++++++ 5 files changed, 230 insertions(+), 1 deletion(-) create mode 100644 packages/node/src/integrations/tracing/elysia/index.ts create mode 100644 packages/node/src/integrations/tracing/elysia/types.ts diff --git a/packages/bun/src/index.ts b/packages/bun/src/index.ts index c2990e6262a7..d44cabef1bc4 100644 --- a/packages/bun/src/index.ts +++ b/packages/bun/src/index.ts @@ -123,6 +123,8 @@ export { setupKoaErrorHandler, connectIntegration, setupConnectErrorHandler, + elysiaIntegration, + setupElysiaErrorHandler, genericPoolIntegration, graphqlIntegration, knexIntegration, diff --git a/packages/node-core/src/utils/ensureIsWrapped.ts b/packages/node-core/src/utils/ensureIsWrapped.ts index 921d01da8207..3d7e34c428fd 100644 --- a/packages/node-core/src/utils/ensureIsWrapped.ts +++ b/packages/node-core/src/utils/ensureIsWrapped.ts @@ -9,7 +9,7 @@ import { isCjs } from './detection'; */ export function ensureIsWrapped( maybeWrappedFunction: unknown, - name: 'express' | 'connect' | 'fastify' | 'hapi' | 'koa' | 'hono', + name: 'express' | 'connect' | 'fastify' | 'hapi' | 'koa' | 'hono' | 'elysia', ): void { const clientOptions = getClient()?.getOptions(); if ( diff --git a/packages/node/src/index.ts b/packages/node/src/index.ts index 8458dee5f6a7..09a1d7fe6856 100644 --- a/packages/node/src/index.ts +++ b/packages/node/src/index.ts @@ -16,6 +16,7 @@ export { postgresJsIntegration } from './integrations/tracing/postgresjs'; export { prismaIntegration } from './integrations/tracing/prisma'; export { hapiIntegration, setupHapiErrorHandler } from './integrations/tracing/hapi'; export { honoIntegration, setupHonoErrorHandler } from './integrations/tracing/hono'; +export { elysiaIntegration, setupElysiaErrorHandler } from './integrations/tracing/elysia'; export { koaIntegration, setupKoaErrorHandler } from './integrations/tracing/koa'; export { connectIntegration, setupConnectErrorHandler } from './integrations/tracing/connect'; export { knexIntegration } from './integrations/tracing/knex'; diff --git a/packages/node/src/integrations/tracing/elysia/index.ts b/packages/node/src/integrations/tracing/elysia/index.ts new file mode 100644 index 000000000000..ca4c916ffffb --- /dev/null +++ b/packages/node/src/integrations/tracing/elysia/index.ts @@ -0,0 +1,138 @@ +import type { IntegrationFn } from '@sentry/core'; +import { + captureException, + debug, + defineIntegration, + getDefaultIsolationScope, + getIsolationScope, +} from '@sentry/core'; +import { SentrySpanProcessor } from '@sentry/opentelemetry'; +import { createRequire } from 'module'; +import { DEBUG_BUILD } from '../../../debug-build'; +import type { ElysiaErrorContext, ElysiaErrorHandler, ElysiaInstance, ElysiaRequestHandler } from './types'; + +const INTEGRATION_NAME = 'Elysia'; + +const _elysiaIntegration = (() => { + return { + name: INTEGRATION_NAME, + setupOnce() { + // No-op: tracing is applied per-instance via setupElysiaErrorHandler + }, + }; +}) satisfies IntegrationFn; + +/** + * Adds Sentry instrumentation for [Elysia](https://elysiajs.com/). + * + * Tracing is powered by Elysia's first-party `@elysiajs/opentelemetry` plugin, + * which is automatically applied when you call `setupElysiaErrorHandler(app)`. + * + * @example + * ```javascript + * const Sentry = require('@sentry/node'); + * + * Sentry.init({ + * integrations: [Sentry.elysiaIntegration()], + * }) + * ``` + */ +export const elysiaIntegration = defineIntegration(_elysiaIntegration); + +interface ElysiaHandlerOptions { + shouldHandleError: (context: ElysiaErrorContext) => boolean; +} + +function defaultShouldHandleError(context: ElysiaErrorContext): boolean { + const status = context.set.status; + if (status === undefined) { + return true; + } + const statusCode = typeof status === 'string' ? parseInt(status, 10) : status; + return statusCode >= 500; +} + +let _cachedOtelPlugin: ((options?: Record) => unknown) | null | undefined; + +function loadElysiaOtelPlugin(): ((options?: Record) => unknown) | null { + if (_cachedOtelPlugin !== undefined) { + return _cachedOtelPlugin; + } + + try { + const _require = createRequire(`${process.cwd()}/`); + const mod = _require('@elysiajs/opentelemetry') as { + opentelemetry?: (options?: Record) => unknown; + }; + _cachedOtelPlugin = mod.opentelemetry ?? null; + } catch { + DEBUG_BUILD && + debug.warn( + 'Could not load `@elysiajs/opentelemetry` package. Please install it to enable tracing for Elysia: `bun add @elysiajs/opentelemetry`', + ); + _cachedOtelPlugin = null; + } + + return _cachedOtelPlugin; +} + +/** + * Add Sentry error handling, request context, and tracing to an Elysia app. + * + * This function: + * 1. Applies `@elysiajs/opentelemetry` for tracing (if installed) + * 2. Registers `onRequest` for request context + * 3. Registers `onError` for error capturing (with `{ as: 'global' }`) + * + * Must be called **before** defining routes so that `onRequest` + * applies to all subsequent handlers. The `onError` hook uses + * `{ as: 'global' }` and applies regardless of registration order. + * + * @param app The Elysia instance + * @param options Configuration options for the handler + * + * @example + * ```javascript + * const Sentry = require('@sentry/node'); + * const { Elysia } = require('elysia'); + * + * const app = new Elysia(); + * + * Sentry.setupElysiaErrorHandler(app); + * + * // Define routes after Sentry setup + * app.get('/', () => 'Hello World'); + * app.listen(3000); + * ``` + */ +export function setupElysiaErrorHandler(app: ElysiaInstance, options?: Partial): void { + const otelPlugin = loadElysiaOtelPlugin(); + if (otelPlugin) { + app.use(otelPlugin({ spanProcessors: [new SentrySpanProcessor()] })); + } + + app.onRequest(((context: { request: Request }) => { + const isolationScope = getIsolationScope(); + if (isolationScope !== getDefaultIsolationScope()) { + isolationScope.setSDKProcessingMetadata({ + normalizedRequest: { + method: context.request.method, + url: context.request.url, + headers: Object.fromEntries(context.request.headers.entries()), + }, + }); + } + }) as ElysiaRequestHandler); + + app.onError({ as: 'global' }, ((context: ElysiaErrorContext) => { + const shouldHandleError = options?.shouldHandleError || defaultShouldHandleError; + if (shouldHandleError(context)) { + captureException(context.error, { + mechanism: { + type: 'elysia', + handled: false, + }, + }); + } + }) as ElysiaErrorHandler); +} diff --git a/packages/node/src/integrations/tracing/elysia/types.ts b/packages/node/src/integrations/tracing/elysia/types.ts new file mode 100644 index 000000000000..80225180ba7b --- /dev/null +++ b/packages/node/src/integrations/tracing/elysia/types.ts @@ -0,0 +1,88 @@ +// Vendored from: https://github.com/elysiajs/elysia/blob/main/src/types.ts + +// Elysia route handler - receives context and returns a response value +// Vendored from: https://github.com/elysiajs/elysia/blob/main/src/types.ts#L36 +export type ElysiaHandler = (context: ElysiaContext) => unknown; + +// Vendored from: https://github.com/elysiajs/elysia/blob/main/src/types.ts +export interface ElysiaContext { + request: Request; + path: string; + route: string; + set: { + headers: Record; + status?: number | string; + redirect?: string; + }; + store: Record; +} + +export interface ElysiaErrorContext extends ElysiaContext { + error: Error; + code: string; +} + +// Lifecycle handler types +export type ElysiaErrorHandler = (context: ElysiaErrorContext) => unknown; +export type ElysiaBeforeHandleHandler = (context: ElysiaContext) => unknown; +export type ElysiaRequestHandler = (context: { request: Request; set: ElysiaContext['set'] }) => unknown; + +// Trace lifecycle event - receives a callback with { onStop, onEvent } +export interface ElysiaTraceProcess { + onStop: (cb: (info: { error?: Error }) => void) => void; + onEvent: (cb: (info: { name: string; onStop: (cb: (info: { error?: Error }) => void) => void }) => void) => void; + total: number; +} + +export interface ElysiaTraceCallbackArgs { + context: ElysiaContext; + onRequest: (cb: (process: ElysiaTraceProcess) => void) => void; + onBeforeHandle: (cb: (process: ElysiaTraceProcess) => void) => void; + onHandle: (cb: (process: { onStop: (cb: (info: { error?: Error }) => void) => void }) => void) => void; + onAfterHandle: (cb: (process: ElysiaTraceProcess) => void) => void; + onError: (cb: (process: ElysiaTraceProcess & { onStop: (cb: (info: { error?: Error }) => void) => void }) => void) => void; + onAfterResponse: (cb: (process: ElysiaTraceProcess & { onStop: (cb: () => void) => void }) => void) => void; +} + +export type ElysiaTraceHandler = (args: ElysiaTraceCallbackArgs) => void; + +// Handler interface for route methods (.get, .post, etc.) +// Vendored from: https://github.com/elysiajs/elysia/blob/main/src/index.ts +export type ElysiaRouteHandlerInterface = { + (path: string, handler: ElysiaHandler, ...rest: unknown[]): ElysiaInstance; +}; + +// Interface for .use() +export type ElysiaUseInterface = { + (plugin: unknown): ElysiaInstance; +}; + +// Minimal Elysia instance interface +// Vendored from: https://github.com/elysiajs/elysia/blob/main/src/index.ts +export interface ElysiaInstance { + get: ElysiaRouteHandlerInterface; + post: ElysiaRouteHandlerInterface; + put: ElysiaRouteHandlerInterface; + delete: ElysiaRouteHandlerInterface; + options: ElysiaRouteHandlerInterface; + patch: ElysiaRouteHandlerInterface; + head: ElysiaRouteHandlerInterface; + all: ElysiaRouteHandlerInterface; + use: ElysiaUseInterface; + onError: { + (options: { as: 'global' | 'scoped' | 'local' }, handler: ElysiaErrorHandler): ElysiaInstance; + (handler: ElysiaErrorHandler): ElysiaInstance; + }; + onRequest: (handler: ElysiaRequestHandler) => ElysiaInstance; + onBeforeHandle: { + (options: { as: 'global' | 'scoped' | 'local' }, handler: ElysiaBeforeHandleHandler): ElysiaInstance; + (handler: ElysiaBeforeHandleHandler): ElysiaInstance; + }; + onAfterResponse: (handler: (context: ElysiaContext) => unknown) => ElysiaInstance; + trace: { + (options: { as: 'global' | 'scoped' | 'local' }, handler: ElysiaTraceHandler): ElysiaInstance; + (handler: ElysiaTraceHandler): ElysiaInstance; + }; +} + +export type Elysia = new (...args: unknown[]) => ElysiaInstance; From 3adfc2482a863294549e4461d674e7b5dde12c67 Mon Sep 17 00:00:00 2001 From: Abdelrahman Awad Date: Mon, 23 Feb 2026 16:53:15 -0500 Subject: [PATCH 2/4] feat: draft withElysia function --- packages/bun/src/index.ts | 2 +- packages/node/src/index.ts | 2 +- .../src/integrations/tracing/elysia/index.ts | 40 +++++---- .../src/integrations/tracing/elysia/types.ts | 85 +++---------------- 4 files changed, 32 insertions(+), 97 deletions(-) diff --git a/packages/bun/src/index.ts b/packages/bun/src/index.ts index d44cabef1bc4..27f53493dc4c 100644 --- a/packages/bun/src/index.ts +++ b/packages/bun/src/index.ts @@ -124,7 +124,7 @@ export { connectIntegration, setupConnectErrorHandler, elysiaIntegration, - setupElysiaErrorHandler, + withElysia, genericPoolIntegration, graphqlIntegration, knexIntegration, diff --git a/packages/node/src/index.ts b/packages/node/src/index.ts index 09a1d7fe6856..e01fb1a0a8a3 100644 --- a/packages/node/src/index.ts +++ b/packages/node/src/index.ts @@ -16,7 +16,7 @@ export { postgresJsIntegration } from './integrations/tracing/postgresjs'; export { prismaIntegration } from './integrations/tracing/prisma'; export { hapiIntegration, setupHapiErrorHandler } from './integrations/tracing/hapi'; export { honoIntegration, setupHonoErrorHandler } from './integrations/tracing/hono'; -export { elysiaIntegration, setupElysiaErrorHandler } from './integrations/tracing/elysia'; +export { elysiaIntegration, withElysia } from './integrations/tracing/elysia'; export { koaIntegration, setupKoaErrorHandler } from './integrations/tracing/koa'; export { connectIntegration, setupConnectErrorHandler } from './integrations/tracing/connect'; export { knexIntegration } from './integrations/tracing/knex'; diff --git a/packages/node/src/integrations/tracing/elysia/index.ts b/packages/node/src/integrations/tracing/elysia/index.ts index ca4c916ffffb..f2021c0307ed 100644 --- a/packages/node/src/integrations/tracing/elysia/index.ts +++ b/packages/node/src/integrations/tracing/elysia/index.ts @@ -9,7 +9,7 @@ import { import { SentrySpanProcessor } from '@sentry/opentelemetry'; import { createRequire } from 'module'; import { DEBUG_BUILD } from '../../../debug-build'; -import type { ElysiaErrorContext, ElysiaErrorHandler, ElysiaInstance, ElysiaRequestHandler } from './types'; +import type { ElysiaErrorContext, ElysiaInstance } from './types'; const INTEGRATION_NAME = 'Elysia'; @@ -17,7 +17,7 @@ const _elysiaIntegration = (() => { return { name: INTEGRATION_NAME, setupOnce() { - // No-op: tracing is applied per-instance via setupElysiaErrorHandler + // No-op: tracing is applied per-instance via withElysia }, }; }) satisfies IntegrationFn; @@ -26,7 +26,7 @@ const _elysiaIntegration = (() => { * Adds Sentry instrumentation for [Elysia](https://elysiajs.com/). * * Tracing is powered by Elysia's first-party `@elysiajs/opentelemetry` plugin, - * which is automatically applied when you call `setupElysiaErrorHandler(app)`. + * which is automatically applied when you call `withElysia(app)`. * * @example * ```javascript @@ -77,41 +77,37 @@ function loadElysiaOtelPlugin(): ((options?: Record) => unknown } /** - * Add Sentry error handling, request context, and tracing to an Elysia app. + * Integrate Sentry with an Elysia app for error handling, request context, + * and tracing. Returns the app instance for chaining. * * This function: * 1. Applies `@elysiajs/opentelemetry` for tracing (if installed) * 2. Registers `onRequest` for request context * 3. Registers `onError` for error capturing (with `{ as: 'global' }`) * - * Must be called **before** defining routes so that `onRequest` - * applies to all subsequent handlers. The `onError` hook uses - * `{ as: 'global' }` and applies regardless of registration order. + * Should be called at the **start** of the chain before defining routes. * * @param app The Elysia instance - * @param options Configuration options for the handler + * @param options Configuration options + * @returns The same Elysia instance for chaining * * @example * ```javascript - * const Sentry = require('@sentry/node'); + * const Sentry = require('@sentry/bun'); * const { Elysia } = require('elysia'); * - * const app = new Elysia(); - * - * Sentry.setupElysiaErrorHandler(app); - * - * // Define routes after Sentry setup - * app.get('/', () => 'Hello World'); - * app.listen(3000); + * Sentry.withElysia(new Elysia()) + * .get('/', () => 'Hello World') + * .listen(3000); * ``` */ -export function setupElysiaErrorHandler(app: ElysiaInstance, options?: Partial): void { +export function withElysia(app: T, options?: Partial): T { const otelPlugin = loadElysiaOtelPlugin(); if (otelPlugin) { app.use(otelPlugin({ spanProcessors: [new SentrySpanProcessor()] })); } - app.onRequest(((context: { request: Request }) => { + app.onRequest((context: { request: Request }) => { const isolationScope = getIsolationScope(); if (isolationScope !== getDefaultIsolationScope()) { isolationScope.setSDKProcessingMetadata({ @@ -122,9 +118,9 @@ export function setupElysiaErrorHandler(app: ElysiaInstance, options?: Partial { + app.onError({ as: 'global' }, (context: ElysiaErrorContext) => { const shouldHandleError = options?.shouldHandleError || defaultShouldHandleError; if (shouldHandleError(context)) { captureException(context.error, { @@ -134,5 +130,7 @@ export function setupElysiaErrorHandler(app: ElysiaInstance, options?: Partial unknown; - -// Vendored from: https://github.com/elysiajs/elysia/blob/main/src/types.ts -export interface ElysiaContext { +export interface ElysiaErrorContext { request: Request; path: string; route: string; @@ -14,75 +7,19 @@ export interface ElysiaContext { status?: number | string; redirect?: string; }; - store: Record; -} - -export interface ElysiaErrorContext extends ElysiaContext { error: Error; code: string; } -// Lifecycle handler types -export type ElysiaErrorHandler = (context: ElysiaErrorContext) => unknown; -export type ElysiaBeforeHandleHandler = (context: ElysiaContext) => unknown; -export type ElysiaRequestHandler = (context: { request: Request; set: ElysiaContext['set'] }) => unknown; - -// Trace lifecycle event - receives a callback with { onStop, onEvent } -export interface ElysiaTraceProcess { - onStop: (cb: (info: { error?: Error }) => void) => void; - onEvent: (cb: (info: { name: string; onStop: (cb: (info: { error?: Error }) => void) => void }) => void) => void; - total: number; -} - -export interface ElysiaTraceCallbackArgs { - context: ElysiaContext; - onRequest: (cb: (process: ElysiaTraceProcess) => void) => void; - onBeforeHandle: (cb: (process: ElysiaTraceProcess) => void) => void; - onHandle: (cb: (process: { onStop: (cb: (info: { error?: Error }) => void) => void }) => void) => void; - onAfterHandle: (cb: (process: ElysiaTraceProcess) => void) => void; - onError: (cb: (process: ElysiaTraceProcess & { onStop: (cb: (info: { error?: Error }) => void) => void }) => void) => void; - onAfterResponse: (cb: (process: ElysiaTraceProcess & { onStop: (cb: () => void) => void }) => void) => void; -} - -export type ElysiaTraceHandler = (args: ElysiaTraceCallbackArgs) => void; - -// Handler interface for route methods (.get, .post, etc.) -// Vendored from: https://github.com/elysiajs/elysia/blob/main/src/index.ts -export type ElysiaRouteHandlerInterface = { - (path: string, handler: ElysiaHandler, ...rest: unknown[]): ElysiaInstance; -}; - -// Interface for .use() -export type ElysiaUseInterface = { - (plugin: unknown): ElysiaInstance; -}; - -// Minimal Elysia instance interface -// Vendored from: https://github.com/elysiajs/elysia/blob/main/src/index.ts +/** + * Loose Elysia instance interface containing only the methods Sentry calls. + * Intentionally minimal so it's compatible with any Elysia version/generics. + */ export interface ElysiaInstance { - get: ElysiaRouteHandlerInterface; - post: ElysiaRouteHandlerInterface; - put: ElysiaRouteHandlerInterface; - delete: ElysiaRouteHandlerInterface; - options: ElysiaRouteHandlerInterface; - patch: ElysiaRouteHandlerInterface; - head: ElysiaRouteHandlerInterface; - all: ElysiaRouteHandlerInterface; - use: ElysiaUseInterface; - onError: { - (options: { as: 'global' | 'scoped' | 'local' }, handler: ElysiaErrorHandler): ElysiaInstance; - (handler: ElysiaErrorHandler): ElysiaInstance; - }; - onRequest: (handler: ElysiaRequestHandler) => ElysiaInstance; - onBeforeHandle: { - (options: { as: 'global' | 'scoped' | 'local' }, handler: ElysiaBeforeHandleHandler): ElysiaInstance; - (handler: ElysiaBeforeHandleHandler): ElysiaInstance; - }; - onAfterResponse: (handler: (context: ElysiaContext) => unknown) => ElysiaInstance; - trace: { - (options: { as: 'global' | 'scoped' | 'local' }, handler: ElysiaTraceHandler): ElysiaInstance; - (handler: ElysiaTraceHandler): ElysiaInstance; - }; + // eslint-disable-next-line @typescript-eslint/no-explicit-any + use: (...args: any[]) => any; + // eslint-disable-next-line @typescript-eslint/no-explicit-any + onRequest: (...args: any[]) => any; + // eslint-disable-next-line @typescript-eslint/no-explicit-any + onError: (...args: any[]) => any; } - -export type Elysia = new (...args: unknown[]) => ElysiaInstance; From 8f94aa6f1cd729f712444c36948d27767af90e6d Mon Sep 17 00:00:00 2001 From: Abdelrahman Awad Date: Tue, 24 Feb 2026 14:09:42 -0500 Subject: [PATCH 3/4] feat: enrich span attributes --- .../src/integrations/tracing/elysia/index.ts | 40 ++++++++++++++++++- 1 file changed, 39 insertions(+), 1 deletion(-) diff --git a/packages/node/src/integrations/tracing/elysia/index.ts b/packages/node/src/integrations/tracing/elysia/index.ts index f2021c0307ed..1e6b62489350 100644 --- a/packages/node/src/integrations/tracing/elysia/index.ts +++ b/packages/node/src/integrations/tracing/elysia/index.ts @@ -1,3 +1,4 @@ +import type { ReadableSpan, Span } from '@opentelemetry/sdk-trace-base'; import type { IntegrationFn } from '@sentry/core'; import { captureException, @@ -5,12 +6,49 @@ import { defineIntegration, getDefaultIsolationScope, getIsolationScope, + SEMANTIC_ATTRIBUTE_SENTRY_OP, + SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, } from '@sentry/core'; import { SentrySpanProcessor } from '@sentry/opentelemetry'; import { createRequire } from 'module'; import { DEBUG_BUILD } from '../../../debug-build'; import type { ElysiaErrorContext, ElysiaInstance } from './types'; +const ELYSIA_LIFECYCLE_OP_MAP: Record = { + Request: 'middleware.elysia', + Parse: 'middleware.elysia', + Transform: 'middleware.elysia', + BeforeHandle: 'middleware.elysia', + Handle: 'request_handler.elysia', + AfterHandle: 'middleware.elysia', + MapResponse: 'middleware.elysia', + AfterResponse: 'middleware.elysia', + Error: 'middleware.elysia', +}; + +const SENTRY_ORIGIN = 'auto.http.otel.elysia'; + +/** + * A custom span processor that filters out empty spans and enriches the span attributes with Sentry attributes. + */ +class ElysiaSentrySpanProcessor extends SentrySpanProcessor { + public override onEnd(span: Span & ReadableSpan): void { + // Elysia produces empty spans as children of lifecycle spans, we want to filter those out. + if (!span.name && Object.keys(span.attributes).length === 0) { + return; + } + + // Enrich the span attributes with Sentry attributes. + const op = ELYSIA_LIFECYCLE_OP_MAP[span.name]; + if (op) { + span.attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP] = op; + span.attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN] = SENTRY_ORIGIN; + } + + super.onEnd(span); + } +} + const INTEGRATION_NAME = 'Elysia'; const _elysiaIntegration = (() => { @@ -104,7 +142,7 @@ function loadElysiaOtelPlugin(): ((options?: Record) => unknown export function withElysia(app: T, options?: Partial): T { const otelPlugin = loadElysiaOtelPlugin(); if (otelPlugin) { - app.use(otelPlugin({ spanProcessors: [new SentrySpanProcessor()] })); + app.use(otelPlugin({ spanProcessors: [new ElysiaSentrySpanProcessor()] })); } app.onRequest((context: { request: Request }) => { From ddc22b6e2bbdff05884addb5ca68617eafc7bcbe Mon Sep 17 00:00:00 2001 From: Abdelrahman Awad Date: Thu, 26 Feb 2026 09:53:36 -0500 Subject: [PATCH 4/4] fix: ignore elysia consistent exports test --- .../node-exports-test-app/scripts/consistentExports.ts | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/dev-packages/e2e-tests/test-applications/node-exports-test-app/scripts/consistentExports.ts b/dev-packages/e2e-tests/test-applications/node-exports-test-app/scripts/consistentExports.ts index 17c6f714c499..1ddb8e57c0b3 100644 --- a/dev-packages/e2e-tests/test-applications/node-exports-test-app/scripts/consistentExports.ts +++ b/dev-packages/e2e-tests/test-applications/node-exports-test-app/scripts/consistentExports.ts @@ -41,6 +41,8 @@ const DEPENDENTS: Dependent[] = [ ignoreExports: [ // Not needed for Astro 'setupFastifyErrorHandler', + 'elysiaIntegration', + 'withElysia', ], }, { @@ -75,6 +77,8 @@ const DEPENDENTS: Dependent[] = [ ignoreExports: [ // Not needed for Serverless 'setupFastifyErrorHandler', + 'elysiaIntegration', + 'withElysia', ], }, { @@ -84,6 +88,8 @@ const DEPENDENTS: Dependent[] = [ ignoreExports: [ // Not needed for Serverless 'setupFastifyErrorHandler', + 'elysiaIntegration', + 'withElysia', ], }, {