@noony-serverless/core 0.3.4 → 0.4.1

package/build/utils/pubsub-trace.utils.d.ts

@@ -0,0 +1,102 @@
+import { Context } from '../core';
+/**
+ * Google Cloud Pub/Sub message structure
+ */
+export interface PubSubMessage {
+    message: {
+        data: string;
+        publishTime?: string;
+        messageId?: string;
+        attributes?: Record<string, string>;
+    };
+}
+/**
+ * W3C Trace Context extracted from Pub/Sub message attributes
+ */
+export interface TraceContext {
+    traceparent?: string;
+    tracestate?: string;
+}
+/**
+ * Type guard to check if request body is a Pub/Sub message
+ *
+ * @param body - Request body to check
+ * @returns True if body is a Pub/Sub message
+ *
+ * @example
+ * if (isPubSubMessage(context.req.body)) {
+ *   const traceContext = extractTraceContext(context.req.body);
+ * }
+ */
+export declare function isPubSubMessage(body: unknown): body is PubSubMessage;
+/**
+ * Extract W3C Trace Context from Pub/Sub message attributes
+ *
+ * Extracts the following headers from message.attributes:
+ * - `traceparent`: W3C Trace Context propagation header (required)
+ * - `tracestate`: Vendor-specific trace state (optional)
+ *
+ * @param message - Pub/Sub message
+ * @returns Trace context object with traceparent and tracestate
+ *
+ * @example
+ * const traceContext = extractTraceContext(pubsubMessage);
+ * if (traceContext.traceparent) {
+ *   console.log('Parent trace ID:', traceContext.traceparent);
+ * }
+ */
+export declare function extractTraceContext(message: PubSubMessage): TraceContext;
+/**
+ * Inject W3C Trace Context into Pub/Sub message attributes
+ *
+ * Adds trace context from the current OpenTelemetry span to message attributes.
+ * This enables distributed tracing across Pub/Sub publishers and subscribers.
+ *
+ * The trace context is extracted using OpenTelemetry's propagation API and
+ * injected into the message attributes as:
+ * - `traceparent`: W3C Trace Context version-traceid-spanid-flags
+ * - `tracestate`: Vendor-specific trace state (if present)
+ *
+ * @param message - Pub/Sub message to inject trace context into
+ * @param context - Noony request context (optional, used to get active span)
+ * @returns Message with trace context injected into attributes
+ *
+ * @example
+ * // Publishing a message with trace context
+ * import { injectTraceContext } from '@noony-serverless/core';
+ *
+ * const message = {
+ *   data: Buffer.from(JSON.stringify({ userId: '123' })).toString('base64'),
+ *   attributes: {
+ *     type: 'user.created'
+ *   }
+ * };
+ *
+ * const tracedMessage = injectTraceContext(message, context);
+ * await pubsub.topic('users').publish(tracedMessage);
+ *
+ * @example
+ * // Publishing without context (uses active span from context)
+ * const tracedMessage = injectTraceContext(message);
+ * await pubsub.topic('users').publish(tracedMessage);
+ */
+export declare function injectTraceContext(message: {
+    data: string;
+    attributes?: Record<string, string>;
+}, context?: Context<unknown, unknown>): {
+    data: string;
+    attributes: Record<string, string>;
+};
+/**
+ * Extract trace context and create parent context for OpenTelemetry
+ *
+ * This is a lower-level utility used internally by OpenTelemetryMiddleware.
+ * Most users should use the middleware's automatic trace propagation instead.
+ *
+ * @param traceContext - Extracted W3C trace context
+ * @returns OpenTelemetry context with extracted trace context
+ *
+ * @internal
+ */
+export declare function createParentContext(traceContext: TraceContext): Record<string, string>;
+//# sourceMappingURL=pubsub-trace.utils.d.ts.map

package/build/utils/pubsub-trace.utils.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPubSubMessage = isPubSubMessage;
+exports.extractTraceContext = extractTraceContext;
+exports.injectTraceContext = injectTraceContext;
+exports.createParentContext = createParentContext;
+/**
+ * Type guard to check if request body is a Pub/Sub message
+ *
+ * @param body - Request body to check
+ * @returns True if body is a Pub/Sub message
+ *
+ * @example
+ * if (isPubSubMessage(context.req.body)) {
+ *   const traceContext = extractTraceContext(context.req.body);
+ * }
+ */
+function isPubSubMessage(body) {
+    return (!!body &&
+        typeof body === 'object' &&
+        'message' in body &&
+        typeof body.message === 'object' &&
+        'data' in body.message);
+}
+/**
+ * Extract W3C Trace Context from Pub/Sub message attributes
+ *
+ * Extracts the following headers from message.attributes:
+ * - `traceparent`: W3C Trace Context propagation header (required)
+ * - `tracestate`: Vendor-specific trace state (optional)
+ *
+ * @param message - Pub/Sub message
+ * @returns Trace context object with traceparent and tracestate
+ *
+ * @example
+ * const traceContext = extractTraceContext(pubsubMessage);
+ * if (traceContext.traceparent) {
+ *   console.log('Parent trace ID:', traceContext.traceparent);
+ * }
+ */
+function extractTraceContext(message) {
+    const attributes = message.message.attributes || {};
+    return {
+        traceparent: attributes.traceparent,
+        tracestate: attributes.tracestate,
+    };
+}
+/**
+ * Inject W3C Trace Context into Pub/Sub message attributes
+ *
+ * Adds trace context from the current OpenTelemetry span to message attributes.
+ * This enables distributed tracing across Pub/Sub publishers and subscribers.
+ *
+ * The trace context is extracted using OpenTelemetry's propagation API and
+ * injected into the message attributes as:
+ * - `traceparent`: W3C Trace Context version-traceid-spanid-flags
+ * - `tracestate`: Vendor-specific trace state (if present)
+ *
+ * @param message - Pub/Sub message to inject trace context into
+ * @param context - Noony request context (optional, used to get active span)
+ * @returns Message with trace context injected into attributes
+ *
+ * @example
+ * // Publishing a message with trace context
+ * import { injectTraceContext } from '@noony-serverless/core';
+ *
+ * const message = {
+ *   data: Buffer.from(JSON.stringify({ userId: '123' })).toString('base64'),
+ *   attributes: {
+ *     type: 'user.created'
+ *   }
+ * };
+ *
+ * const tracedMessage = injectTraceContext(message, context);
+ * await pubsub.topic('users').publish(tracedMessage);
+ *
+ * @example
+ * // Publishing without context (uses active span from context)
+ * const tracedMessage = injectTraceContext(message);
+ * await pubsub.topic('users').publish(tracedMessage);
+ */
+function injectTraceContext(message, context) {
+    // Initialize attributes if not present
+    const attributes = message.attributes || {};
+    try {
+        // Try to use OpenTelemetry API if available
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const otelApi = require('@opentelemetry/api');
+        const { trace, propagation, context: otelContext } = otelApi;
+        // Get current context (either from provided context or active context)
+        let activeContext = otelContext.active();
+        // If Noony context provided, try to get span from businessData
+        if (context) {
+            const span = context.businessData.get('otel_span');
+            if (span && typeof span === 'object' && 'spanContext' in span) {
+                // Create context with span
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                activeContext = trace.setSpan(activeContext, span);
+            }
+        }
+        // Get active span if no span found in businessData
+        const activeSpan = trace.getSpan(activeContext);
+        if (!activeSpan) {
+            // No active span, return message without trace context
+            return {
+                data: message.data,
+                attributes,
+            };
+        }
+        // Inject trace context into a carrier object
+        const carrier = {};
+        propagation.inject(activeContext, carrier);
+        // Merge trace context into message attributes
+        return {
+            data: message.data,
+            attributes: {
+                ...attributes,
+                ...carrier, // This adds traceparent and tracestate
+            },
+        };
+    }
+    catch (error) {
+        // OpenTelemetry not available or error during injection
+        // Return message without trace context (fail gracefully)
+        console.warn('[Telemetry] Failed to inject trace context:', error);
+        return {
+            data: message.data,
+            attributes,
+        };
+    }
+}
+/**
+ * Extract trace context and create parent context for OpenTelemetry
+ *
+ * This is a lower-level utility used internally by OpenTelemetryMiddleware.
+ * Most users should use the middleware's automatic trace propagation instead.
+ *
+ * @param traceContext - Extracted W3C trace context
+ * @returns OpenTelemetry context with extracted trace context
+ *
+ * @internal
+ */
+function createParentContext(traceContext) {
+    if (!traceContext.traceparent) {
+        return {};
+    }
+    const carrier = {
+        traceparent: traceContext.traceparent,
+    };
+    if (traceContext.tracestate) {
+        carrier.tracestate = traceContext.tracestate;
+    }
+    return carrier;
+}
+//# sourceMappingURL=pubsub-trace.utils.js.map

package/build/utils/wrapper-utils.d.ts

@@ -0,0 +1,177 @@
+import type { HttpFunction } from '@google-cloud/functions-framework';
+import type { Request, Response } from 'express';
+import { Handler } from '../core/handler';
+/**
+ * Create an HttpFunction wrapper for a Noony handler
+ *
+ * Wraps a Noony handler into a Google Cloud Functions `HttpFunction` for production deployment.
+ * This pattern ensures proper initialization, error handling, and prevents double responses.
+ *
+ * @param noonyHandler - The Noony handler to wrap (contains middleware chain and controller)
+ * @param functionName - Name for error logging purposes
+ * @param initializeDependencies - Async function that initializes dependencies (database, services, etc.)
+ *                                  Uses singleton pattern to prevent re-initialization on warm starts
+ * @returns HttpFunction compatible with `@google-cloud/functions-framework`
+ *
+ * @remarks
+ * This function ensures:
+ * - Dependencies are initialized before handler execution (optimized for cold/warm starts)
+ * - Errors are caught and returned as proper HTTP responses
+ * - Response is not sent twice (`headersSent` check)
+ * - `RESPONSE_SENT` errors are ignored (response already sent by middleware)
+ * - Real errors return 500 with generic message for security
+ *
+ * @example
+ * Creating and registering Cloud Functions:
+ * ```typescript
+ * import { http } from '@google-cloud/functions-framework';
+ * import { createHttpFunction } from '@noony-serverless/core';
+ * import { loginHandler } from './handlers/auth.handlers';
+ *
+ * // Initialize dependencies once per cold start
+ * let initialized = false;
+ * async function initializeDependencies(): Promise<void> {
+ *   if (initialized) return;
+ *   const db = await databaseService.connect();
+ *   await initializeServices(db);
+ *   initialized = true;
+ * }
+ *
+ * // Create and register function
+ * const loginFunction = createHttpFunction(
+ *   loginHandler,
+ *   'login',
+ *   initializeDependencies
+ * );
+ * http('login', loginFunction);
+ * export const login = loginFunction;
+ * ```
+ *
+ * @example
+ * Execution flow:
+ * ```
+ * HTTP Request → createHttpFunction wrapper
+ *                    │
+ *                    ▼
+ *            initializeDependencies() (only on cold start)
+ *                    │
+ *                    ▼
+ *            noonyHandler.execute(req, res)
+ *                    │
+ *                    ├─── errorHandler()
+ *                    ├─── authMiddleware()
+ *                    ├─── requirePermission()
+ *                    ├─── bodyValidator()
+ *                    ├─── ResponseWrapperMiddleware
+ *                    └─── Controller function
+ *                              │
+ *                              ▼
+ *                      HTTP Response
+ * ```
+ *
+ * @see {@link wrapNoonyHandler} for Express integration (local development)
+ */
+export declare function createHttpFunction(noonyHandler: Handler<unknown>, functionName: string, initializeDependencies: () => Promise<void>): HttpFunction;
+/**
+ * Wrap a Noony handler for use with Express routing
+ *
+ * Wraps a Noony handler into an Express route handler for local development environments.
+ * This pattern enables running all endpoints through a single Express app with standard
+ * Express routing, middleware, and error handling.
+ *
+ * @param noonyHandler - The Noony handler to wrap (contains middleware chain and controller)
+ * @param functionName - Name for error logging purposes
+ * @param initializeDependencies - Async function that initializes dependencies (database, services, etc.)
+ *                                  Uses singleton pattern to prevent re-initialization across requests
+ * @returns Express route handler compatible with Express Router: `(req: Request, res: Response) => Promise<void>`
+ *
+ * @remarks
+ * This wrapper ensures:
+ * - Dependencies are initialized before handler execution (singleton pattern for efficiency)
+ * - Noony handlers work seamlessly with Express routing and middleware
+ * - Errors are caught and returned as proper HTTP responses
+ * - Response is not sent twice (`headersSent` check)
+ * - `RESPONSE_SENT` errors are ignored (response already sent by middleware)
+ * - Real errors return 500 with generic message for security
+ *
+ * **Differences from createHttpFunction:**
+ *
+ * | Aspect | createHttpFunction | wrapNoonyHandler |
+ * |--------|-------------------|------------------|
+ * | **Use case** | Production deployment | Local development |
+ * | **Framework** | Cloud Functions Framework | Express |
+ * | **Return type** | `HttpFunction` | Express handler |
+ * | **Registration** | `http('name', fn)` | `app.get('/path', fn)` |
+ * | **Deployment** | Individual functions | Single Express app |
+ *
+ * @example
+ * Creating Express app with multiple routes:
+ * ```typescript
+ * import express, { Express } from 'express';
+ * import { wrapNoonyHandler } from '@noony-serverless/core';
+ * import { loginHandler, logoutHandler, getConfigHandler } from './handlers';
+ *
+ * // Initialize dependencies once per app startup
+ * let initialized = false;
+ * async function initializeDependencies(): Promise<void> {
+ *   if (initialized) return;
+ *   const db = await databaseService.connect();
+ *   await initializeServices(db);
+ *   initialized = true;
+ * }
+ *
+ * function createExpressApp(): Express {
+ *   const app = express();
+ *
+ *   // Global Express middleware
+ *   app.use(cors());
+ *   app.use(express.json());
+ *
+ *   // Health check (no DB required)
+ *   app.get('/health', (_req, res) => {
+ *     res.json({ success: true, data: { status: 'healthy' } });
+ *   });
+ *
+ *   // Auth routes
+ *   app.post('/api/auth/login', wrapNoonyHandler(loginHandler, 'login', initializeDependencies));
+ *   app.post('/api/auth/logout', wrapNoonyHandler(logoutHandler, 'logout', initializeDependencies));
+ *
+ *   // Config routes
+ *   app.get('/api/config', wrapNoonyHandler(getConfigHandler, 'getConfig', initializeDependencies));
+ *
+ *   // 404 handler
+ *   app.use((_req, res) => {
+ *     res.status(404).json({
+ *       success: false,
+ *       error: { code: 'NOT_FOUND', message: 'Endpoint not found' }
+ *     });
+ *   });
+ *
+ *   return app;
+ * }
+ *
+ * // Start server
+ * const app = createExpressApp();
+ * const PORT = process.env.PORT || 3000;
+ * app.listen(PORT, () => {
+ *   console.log(`Server running on port ${PORT}`);
+ * });
+ * ```
+ *
+ * @example
+ * Express routing with path parameters:
+ * ```typescript
+ * const app = express();
+ *
+ * // Routes with path parameters work seamlessly
+ * app.get('/api/users/:userId', wrapNoonyHandler(getUserHandler, 'getUser', initializeDependencies));
+ * app.patch('/api/config/sections/:sectionId', wrapNoonyHandler(updateSectionHandler, 'updateSection', initializeDependencies));
+ * app.delete('/api/config/sections/:sectionId', wrapNoonyHandler(deleteSectionHandler, 'deleteSection', initializeDependencies));
+ *
+ * // Path parameters available in Noony handler via context.req.params
+ * ```
+ *
+ * @see {@link createHttpFunction} for Cloud Functions Framework integration (production deployment)
+ */
+export declare function wrapNoonyHandler(noonyHandler: Handler<unknown>, functionName: string, initializeDependencies: () => Promise<void>): (req: Request, res: Response) => Promise<void>;
+//# sourceMappingURL=wrapper-utils.d.ts.map

package/build/utils/wrapper-utils.js

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHttpFunction = createHttpFunction;
+exports.wrapNoonyHandler = wrapNoonyHandler;
+const logger_1 = require("../core/logger");
+/**
+ * Create an HttpFunction wrapper for a Noony handler
+ *
+ * Wraps a Noony handler into a Google Cloud Functions `HttpFunction` for production deployment.
+ * This pattern ensures proper initialization, error handling, and prevents double responses.
+ *
+ * @param noonyHandler - The Noony handler to wrap (contains middleware chain and controller)
+ * @param functionName - Name for error logging purposes
+ * @param initializeDependencies - Async function that initializes dependencies (database, services, etc.)
+ *                                  Uses singleton pattern to prevent re-initialization on warm starts
+ * @returns HttpFunction compatible with `@google-cloud/functions-framework`
+ *
+ * @remarks
+ * This function ensures:
+ * - Dependencies are initialized before handler execution (optimized for cold/warm starts)
+ * - Errors are caught and returned as proper HTTP responses
+ * - Response is not sent twice (`headersSent` check)
+ * - `RESPONSE_SENT` errors are ignored (response already sent by middleware)
+ * - Real errors return 500 with generic message for security
+ *
+ * @example
+ * Creating and registering Cloud Functions:
+ * ```typescript
+ * import { http } from '@google-cloud/functions-framework';
+ * import { createHttpFunction } from '@noony-serverless/core';
+ * import { loginHandler } from './handlers/auth.handlers';
+ *
+ * // Initialize dependencies once per cold start
+ * let initialized = false;
+ * async function initializeDependencies(): Promise<void> {
+ *   if (initialized) return;
+ *   const db = await databaseService.connect();
+ *   await initializeServices(db);
+ *   initialized = true;
+ * }
+ *
+ * // Create and register function
+ * const loginFunction = createHttpFunction(
+ *   loginHandler,
+ *   'login',
+ *   initializeDependencies
+ * );
+ * http('login', loginFunction);
+ * export const login = loginFunction;
+ * ```
+ *
+ * @example
+ * Execution flow:
+ * ```
+ * HTTP Request → createHttpFunction wrapper
+ *                    │
+ *                    ▼
+ *            initializeDependencies() (only on cold start)
+ *                    │
+ *                    ▼
+ *            noonyHandler.execute(req, res)
+ *                    │
+ *                    ├─── errorHandler()
+ *                    ├─── authMiddleware()
+ *                    ├─── requirePermission()
+ *                    ├─── bodyValidator()
+ *                    ├─── ResponseWrapperMiddleware
+ *                    └─── Controller function
+ *                              │
+ *                              ▼
+ *                      HTTP Response
+ * ```
+ *
+ * @see {@link wrapNoonyHandler} for Express integration (local development)
+ */
+function createHttpFunction(noonyHandler, functionName, initializeDependencies) {
+    return async (req, res) => {
+        try {
+            // Ensure dependencies are initialized
+            await initializeDependencies();
+            // Execute Noony handler (runs middleware chain + controller)
+            // Cast is safe because Handler.execute internally adapts GCP Request/Response
+            await noonyHandler.execute(req, res);
+        }
+        catch (error) {
+            // Only handle errors if they're real errors (not RESPONSE_SENT markers)
+            if (error instanceof Error && error.message === 'RESPONSE_SENT') {
+                return;
+            }
+            logger_1.logger.error(`${functionName} function error`, {
+                error: error instanceof Error ? error.message : 'Unknown error',
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+            // Graceful error handling - only send if headers not already sent
+            if (!res.headersSent) {
+                res.status(500).json({
+                    success: false,
+                    error: {
+                        code: 'INTERNAL_SERVER_ERROR',
+                        message: 'An unexpected error occurred',
+                    },
+                });
+            }
+        }
+    };
+}
+/**
+ * Wrap a Noony handler for use with Express routing
+ *
+ * Wraps a Noony handler into an Express route handler for local development environments.
+ * This pattern enables running all endpoints through a single Express app with standard
+ * Express routing, middleware, and error handling.
+ *
+ * @param noonyHandler - The Noony handler to wrap (contains middleware chain and controller)
+ * @param functionName - Name for error logging purposes
+ * @param initializeDependencies - Async function that initializes dependencies (database, services, etc.)
+ *                                  Uses singleton pattern to prevent re-initialization across requests
+ * @returns Express route handler compatible with Express Router: `(req: Request, res: Response) => Promise<void>`
+ *
+ * @remarks
+ * This wrapper ensures:
+ * - Dependencies are initialized before handler execution (singleton pattern for efficiency)
+ * - Noony handlers work seamlessly with Express routing and middleware
+ * - Errors are caught and returned as proper HTTP responses
+ * - Response is not sent twice (`headersSent` check)
+ * - `RESPONSE_SENT` errors are ignored (response already sent by middleware)
+ * - Real errors return 500 with generic message for security
+ *
+ * **Differences from createHttpFunction:**
+ *
+ * | Aspect | createHttpFunction | wrapNoonyHandler |
+ * |--------|-------------------|------------------|
+ * | **Use case** | Production deployment | Local development |
+ * | **Framework** | Cloud Functions Framework | Express |
+ * | **Return type** | `HttpFunction` | Express handler |
+ * | **Registration** | `http('name', fn)` | `app.get('/path', fn)` |
+ * | **Deployment** | Individual functions | Single Express app |
+ *
+ * @example
+ * Creating Express app with multiple routes:
+ * ```typescript
+ * import express, { Express } from 'express';
+ * import { wrapNoonyHandler } from '@noony-serverless/core';
+ * import { loginHandler, logoutHandler, getConfigHandler } from './handlers';
+ *
+ * // Initialize dependencies once per app startup
+ * let initialized = false;
+ * async function initializeDependencies(): Promise<void> {
+ *   if (initialized) return;
+ *   const db = await databaseService.connect();
+ *   await initializeServices(db);
+ *   initialized = true;
+ * }
+ *
+ * function createExpressApp(): Express {
+ *   const app = express();
+ *
+ *   // Global Express middleware
+ *   app.use(cors());
+ *   app.use(express.json());
+ *
+ *   // Health check (no DB required)
+ *   app.get('/health', (_req, res) => {
+ *     res.json({ success: true, data: { status: 'healthy' } });
+ *   });
+ *
+ *   // Auth routes
+ *   app.post('/api/auth/login', wrapNoonyHandler(loginHandler, 'login', initializeDependencies));
+ *   app.post('/api/auth/logout', wrapNoonyHandler(logoutHandler, 'logout', initializeDependencies));
+ *
+ *   // Config routes
+ *   app.get('/api/config', wrapNoonyHandler(getConfigHandler, 'getConfig', initializeDependencies));
+ *
+ *   // 404 handler
+ *   app.use((_req, res) => {
+ *     res.status(404).json({
+ *       success: false,
+ *       error: { code: 'NOT_FOUND', message: 'Endpoint not found' }
+ *     });
+ *   });
+ *
+ *   return app;
+ * }
+ *
+ * // Start server
+ * const app = createExpressApp();
+ * const PORT = process.env.PORT || 3000;
+ * app.listen(PORT, () => {
+ *   console.log(`Server running on port ${PORT}`);
+ * });
+ * ```
+ *
+ * @example
+ * Express routing with path parameters:
+ * ```typescript
+ * const app = express();
+ *
+ * // Routes with path parameters work seamlessly
+ * app.get('/api/users/:userId', wrapNoonyHandler(getUserHandler, 'getUser', initializeDependencies));
+ * app.patch('/api/config/sections/:sectionId', wrapNoonyHandler(updateSectionHandler, 'updateSection', initializeDependencies));
+ * app.delete('/api/config/sections/:sectionId', wrapNoonyHandler(deleteSectionHandler, 'deleteSection', initializeDependencies));
+ *
+ * // Path parameters available in Noony handler via context.req.params
+ * ```
+ *
+ * @see {@link createHttpFunction} for Cloud Functions Framework integration (production deployment)
+ */
+function wrapNoonyHandler(noonyHandler, functionName, initializeDependencies) {
+    return async (req, res) => {
+        try {
+            // Ensure dependencies are initialized
+            await initializeDependencies();
+            // Execute Noony handler with Express req/res (cast to generic types)
+            await noonyHandler.executeGeneric(req, res);
+        }
+        catch (error) {
+            if (error instanceof Error && error.message === 'RESPONSE_SENT') {
+                return;
+            }
+            logger_1.logger.error(`${functionName} handler error`, {
+                error: error instanceof Error ? error.message : 'Unknown error',
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+            if (!res.headersSent) {
+                res.status(500).json({
+                    success: false,
+                    error: {
+                        code: 'INTERNAL_SERVER_ERROR',
+                        message: 'An unexpected error occurred',
+                    },
+                });
+            }
+        }
+    };
+}
+//# sourceMappingURL=wrapper-utils.js.map