fix: add fallback for databases without transaction support

Some database adapters don't support transactions, causing payment
updates to fail completely. This change adds graceful fallback to
direct updates when transactions are unavailable.

Changes:
- Try to use transactions if supported
- Fall back to direct update if beginTransaction() fails or returns null
- Add debug logging to track which path is used
- Maintain backward compatibility with transaction-supporting databases

This fixes the "Failed to begin transaction" error in production.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xtr-dev/payload-billing",
-  "version": "0.1.14",
+  "version": "0.1.28",
   "description": "PayloadCMS plugin for billing and payment provider integrations with tracking and local testing",
   "license": "MIT",
   "type": "module",

src/collections/hooks.ts

@@ -4,6 +4,14 @@ import { useBillingPlugin } from '../plugin/index'
 
 export const initProviderPayment = async (payload: Payload, payment: Partial<Payment>): Promise<Partial<Payment>> => {
   const billing = useBillingPlugin(payload)
+
+  if (!billing) {
+    throw new Error(
+      'Billing plugin not initialized. Make sure the billingPlugin is properly configured in your Payload config and that Payload has finished initializing. ' +
+      'If you are calling this from a Next.js API route or Server Component, ensure you are using getPayload() with the same config instance used in your Payload configuration.'
+    )
+  }
+
   if (!payment.provider || !billing.providerConfig[payment.provider]) {
     throw new Error(`Provider ${payment.provider} not found.`)
   }

src/collections/payments.ts

@@ -78,6 +78,21 @@ export function createPaymentsCollection(pluginConfig: BillingPluginConfig): Col
         description: 'Payment description',
       },
     },
+    {
+      name: 'checkoutUrl',
+      type: 'text',
+      admin: {
+        description: 'Checkout URL where user can complete payment (if applicable)',
+        readOnly: true,
+      },
+    },
+    {
+      name: 'redirectUrl',
+      type: 'text',
+      admin: {
+        description: 'URL to redirect user after payment completion',
+      },
+    },
     {
       name: 'invoice',
       type: 'relationship',
@@ -136,6 +151,18 @@ export function createPaymentsCollection(pluginConfig: BillingPluginConfig): Col
       useAsTitle: 'id',
     },
     fields,
+    defaultPopulate: {
+      id: true,
+      provider: true,
+      status: true,
+      amount: true,
+      currency: true,
+      description: true,
+      checkoutUrl: true,
+      providerId: true,
+      metadata: true,
+      providerData: true,
+    },
     hooks: {
       afterChange: [
         async ({ doc, operation, req, previousDoc }) => {

src/plugin/index.ts

@@ -4,7 +4,7 @@ import type { Config, Payload } from 'payload'
 import { createSingleton } from './singleton'
 import type { PaymentProvider } from '../providers/index'
 
-const singleton = createSingleton(Symbol('billingPlugin'))
+const singleton = createSingleton(Symbol.for('@xtr-dev/payload-billing'))
 
 type BillingPlugin = {
   config: BillingPluginConfig
@@ -13,7 +13,7 @@ type BillingPlugin = {
   }
 }
 
-export const useBillingPlugin = (payload: Payload) => singleton.get(payload) as BillingPlugin
+export const useBillingPlugin = (payload: Payload) => singleton.get(payload) as BillingPlugin | undefined
 
 export const billingPlugin = (pluginConfig: BillingPluginConfig = {}) => (config: Config): Config => {
   if (pluginConfig.disabled) {

src/plugin/types/payments.ts

@@ -22,6 +22,14 @@ export interface Payment {
    * Payment description
    */
   description?: string | null;
+  /**
+   * Checkout URL where user can complete payment (if applicable)
+   */
+  checkoutUrl?: string | null;
+  /**
+   * URL to redirect user after payment completion
+   */
+  redirectUrl?: string | null;
   invoice?: (Id | null) | Invoice;
   /**
    * Additional metadata for the payment

src/providers/mollie.ts

@@ -14,7 +14,7 @@ import {
 import { formatAmountForProvider, isValidAmount, isValidCurrencyCode } from './currency'
 import { createContextLogger } from '../utils/logger'
 
-const symbol = Symbol('mollie')
+const symbol = Symbol.for('@xtr-dev/payload-billing/mollie')
 export type MollieProviderConfig = Parameters<typeof createMollieClient>[0]
 
 /**
@@ -85,11 +85,15 @@ export const mollieProvider = (mollieConfig: MollieProviderConfig & {
               const status = mapMollieStatusToPaymentStatus(molliePayment.status)
 
               // Update the payment status and provider data
+              // Use toPlainObject if available, otherwise spread the object
+              const providerData = typeof molliePayment.toPlainObject === 'function'
+                ? molliePayment.toPlainObject()
+                : { ...molliePayment }
               const updateSuccess = await updatePaymentStatus(
                 payload,
                 payment.id,
                 status,
-                molliePayment.toPlainObject(),
+                providerData,
                 pluginConfig
               )
 
@@ -134,11 +138,24 @@ export const mollieProvider = (mollieConfig: MollieProviderConfig & {
       }
 
       // Setup URLs with development defaults
+      // Only use localhost fallbacks in non-production environments
       const isProduction = process.env.NODE_ENV === 'production'
-      const redirectUrl = mollieConfig.redirectUrl ||
-        (!isProduction ? 'https://localhost:3000/payment/success' : undefined)
-      const webhookUrl = mollieConfig.webhookUrl ||
-        `${process.env.PAYLOAD_PUBLIC_SERVER_URL || (!isProduction ? 'https://localhost:3000' : '')}/api/payload-billing/mollie/webhook`
+      const serverUrl = process.env.NEXT_PUBLIC_SERVER_URL || process.env.PAYLOAD_PUBLIC_SERVER_URL || process.env.SERVER_URL
+
+      // Priority: payment.redirectUrl > config.redirectUrl > dev fallback
+      let redirectUrl = payment.redirectUrl || mollieConfig.redirectUrl
+      if (!redirectUrl && !isProduction) {
+        redirectUrl = 'https://localhost:3000/payment/success'
+      }
+
+      let webhookUrl = mollieConfig.webhookUrl
+      if (!webhookUrl) {
+        if (serverUrl) {
+          webhookUrl = `${serverUrl}/api/payload-billing/mollie/webhook`
+        } else if (!isProduction) {
+          webhookUrl = 'https://localhost:3000/api/payload-billing/mollie/webhook'
+        }
+      }
 
       // Validate URLs for production
       validateProductionUrl(redirectUrl, 'Redirect')
@@ -154,7 +171,11 @@ export const mollieProvider = (mollieConfig: MollieProviderConfig & {
         webhookUrl,
       });
       payment.providerId = molliePayment.id
-      payment.providerData = molliePayment.toPlainObject()
+      // Use toPlainObject if available, otherwise spread the object (for compatibility with different Mollie client versions)
+      payment.providerData = typeof molliePayment.toPlainObject === 'function'
+        ? molliePayment.toPlainObject()
+        : { ...molliePayment }
+      payment.checkoutUrl = molliePayment._links?.checkout?.href || null
       return payment
     },
   } satisfies PaymentProvider

src/providers/stripe.ts

@@ -14,7 +14,7 @@ import {
 import { isValidAmount, isValidCurrencyCode } from './currency'
 import { createContextLogger } from '../utils/logger'
 
-const symbol = Symbol('stripe')
+const symbol = Symbol.for('@xtr-dev/payload-billing/stripe')
 
 export interface StripeProviderConfig {
   secretKey: string
@@ -234,6 +234,9 @@ export const stripeProvider = (stripeConfig: StripeProviderConfig) => {
 
       const stripe = singleton.get(payload)
 
+      // Priority: payment.redirectUrl > config.returnUrl
+      const returnUrl = payment.redirectUrl || stripeConfig.returnUrl
+
       // Create a payment intent
       const paymentIntent = await stripe.paymentIntents.create({
         amount: payment.amount, // Stripe handles currency conversion internally
@@ -250,6 +253,7 @@ export const stripeProvider = (stripeConfig: StripeProviderConfig) => {
         automatic_payment_methods: {
           enabled: true,
         },
+        ...(returnUrl && { return_url: returnUrl }),
       })
 
       payment.providerId = paymentIntent.id

src/providers/test.ts

@@ -1,12 +1,12 @@
 import type { Payment } from '../plugin/types/payments'
 import type { PaymentProvider, ProviderData } from '../plugin/types/index'
 import type { BillingPluginConfig } from '../plugin/config'
-import type { Payload } from 'payload'
+import type { CollectionSlug, Payload } from 'payload'
 import { handleWebhookError, logWebhookEvent } from './utils'
 import { isValidAmount, isValidCurrencyCode } from './currency'
 import { createContextLogger } from '../utils/logger'
 
-const TestModeWarningSymbol = Symbol('TestModeWarning')
+const TestModeWarningSymbol = Symbol.for('@xtr-dev/payload-billing/test-mode-warning')
 const hasGivenTestModeWarning = () => TestModeWarningSymbol in globalThis
 const setTestModeWarning = () => ((<any>globalThis)[TestModeWarningSymbol] = true)
 
@@ -160,6 +160,7 @@ export interface TestPaymentSession {
   method?: PaymentMethod
   createdAt: Date
   status: PaymentOutcome
+  redirectUrl?: string
 }
 
 // Use the proper BillingPluginConfig type
@@ -228,7 +229,7 @@ export const testProvider = (testConfig: TestProviderConfig) => {
   }
 
   const scenarios = testConfig.scenarios || DEFAULT_SCENARIOS
-  const baseUrl = testConfig.baseUrl || (process.env.PAYLOAD_PUBLIC_SERVER_URL || 'http://localhost:3000')
+  const baseUrl = testConfig.baseUrl || process.env.NEXT_PUBLIC_SERVER_URL || process.env.PAYLOAD_PUBLIC_SERVER_URL || process.env.SERVER_URL || 'http://localhost:3000'
   const uiRoute = testConfig.customUiRoute || '/test-payment'
 
   // Test mode warnings will be logged in onInit when payload is available
@@ -242,10 +243,15 @@ export const testProvider = (testConfig: TestProviderConfig) => {
         {
           path: '/payload-billing/test/payment/:id',
           method: 'get',
-          handler: (req) => {
+          handler: async (req) => {
             // Extract payment ID from URL path
             const urlParts = req.url?.split('/') || []
-            const paymentId = urlParts[urlParts.length - 1]
+            let paymentId = urlParts[urlParts.length - 1]
+
+            // Remove query parameters if present
+            if (paymentId?.includes('?')) {
+              paymentId = paymentId.split('?')[0]
+            }
 
             if (!paymentId) {
               return new Response(JSON.stringify({ error: 'Payment ID required' }), {
@@ -263,7 +269,41 @@ export const testProvider = (testConfig: TestProviderConfig) => {
               })
             }
 
-            const session = testPaymentSessions.get(paymentId)
+            // Try to get session from memory first (for backward compatibility)
+            let session = testPaymentSessions.get(paymentId)
+
+            // If not in memory, fetch from database
+            if (!session && req.payload) {
+              try {
+                const paymentsConfig = pluginConfig.collections?.payments
+                const paymentSlug = typeof paymentsConfig === 'string' ? paymentsConfig : (paymentsConfig?.slug || 'payments')
+                const result = await req.payload.find({
+                  collection: paymentSlug as CollectionSlug,
+                  where: {
+                    providerId: {
+                      equals: paymentId
+                    }
+                  },
+                  limit: 1
+                })
+
+                if (result.docs && result.docs.length > 0) {
+                  const payment = result.docs[0] as Payment
+                  // Create session from database payment
+                  session = {
+                    id: paymentId,
+                    payment: payment,
+                    createdAt: new Date(payment.createdAt || Date.now()),
+                    status: 'pending' as PaymentOutcome
+                  }
+                  // Store in memory for future requests
+                  testPaymentSessions.set(paymentId, session)
+                }
+              } catch (error) {
+                console.error('Error fetching payment from database:', error)
+              }
+            }
+
             if (!session) {
               return new Response(JSON.stringify({ error: 'Payment session not found' }), {
                 status: 404,
@@ -271,8 +311,11 @@ export const testProvider = (testConfig: TestProviderConfig) => {
               })
             }
 
+            // Determine redirect URL: session.redirectUrl > payment.redirectUrl > default
+            const redirectUrl = session.redirectUrl || (session.payment as Payment)?.redirectUrl || `${baseUrl}/payment/success`
+
             // Generate test payment UI
-            const html = generateTestPaymentUI(session, scenarios, uiRoute, baseUrl, testConfig)
+            const html = generateTestPaymentUI(session, scenarios, uiRoute, baseUrl, testConfig, redirectUrl)
             return new Response(html, {
               headers: { 'Content-Type': 'text/html' }
             })
@@ -322,7 +365,41 @@ export const testProvider = (testConfig: TestProviderConfig) => {
 
               const { paymentId, scenarioId, method } = validation.data!
 
-              const session = testPaymentSessions.get(paymentId)
+              // Try to get session from memory first
+              let session = testPaymentSessions.get(paymentId)
+
+              // If not in memory, fetch from database
+              if (!session && req.payload) {
+                try {
+                  const paymentsConfig = pluginConfig.collections?.payments
+                const paymentSlug = typeof paymentsConfig === 'string' ? paymentsConfig : (paymentsConfig?.slug || 'payments')
+                  const result = await req.payload.find({
+                    collection: paymentSlug as CollectionSlug,
+                    where: {
+                      providerId: {
+                        equals: paymentId
+                      }
+                    },
+                    limit: 1
+                  })
+
+                  if (result.docs && result.docs.length > 0) {
+                    const payment = result.docs[0] as Payment
+                    // Create session from database payment
+                    session = {
+                      id: paymentId,
+                      payment: payment,
+                      createdAt: new Date(payment.createdAt || Date.now()),
+                      status: 'pending' as PaymentOutcome
+                    }
+                    // Store in memory for future requests
+                    testPaymentSessions.set(paymentId, session)
+                  }
+                } catch (error) {
+                  console.error('Error fetching payment from database:', error)
+                }
+              }
+
               if (!session) {
                 return new Response(JSON.stringify({ error: 'Payment session not found' }), {
                   status: 404,
@@ -347,7 +424,8 @@ export const testProvider = (testConfig: TestProviderConfig) => {
               setTimeout(() => {
                 processTestPayment(payload, session, pluginConfig).catch(async (error) => {
                   const logger = createContextLogger(payload, 'Test Provider')
-                  logger.error('Failed to process payment:', error)
+                  const errorMessage = error instanceof Error ? error.message : String(error)
+                  logger.error(`Failed to process payment: ${errorMessage}`)
 
                   // Ensure session status is updated consistently
                   session.status = 'failed'
@@ -398,10 +476,15 @@ export const testProvider = (testConfig: TestProviderConfig) => {
         {
           path: '/payload-billing/test/status/:id',
           method: 'get',
-          handler: (req) => {
+          handler: async (req) => {
             // Extract payment ID from URL path
             const urlParts = req.url?.split('/') || []
-            const paymentId = urlParts[urlParts.length - 1]
+            let paymentId = urlParts[urlParts.length - 1]
+
+            // Remove query parameters if present
+            if (paymentId?.includes('?')) {
+              paymentId = paymentId.split('?')[0]
+            }
 
             if (!paymentId) {
               return new Response(JSON.stringify({ error: 'Payment ID required' }), {
@@ -419,7 +502,41 @@ export const testProvider = (testConfig: TestProviderConfig) => {
               })
             }
 
-            const session = testPaymentSessions.get(paymentId)
+            // Try to get session from memory first
+            let session = testPaymentSessions.get(paymentId)
+
+            // If not in memory, fetch from database
+            if (!session && req.payload) {
+              try {
+                const paymentsConfig = pluginConfig.collections?.payments
+                const paymentSlug = typeof paymentsConfig === 'string' ? paymentsConfig : (paymentsConfig?.slug || 'payments')
+                const result = await req.payload.find({
+                  collection: paymentSlug,
+                  where: {
+                    providerId: {
+                      equals: paymentId
+                    }
+                  },
+                  limit: 1
+                })
+
+                if (result.docs && result.docs.length > 0) {
+                  const payment = result.docs[0] as Payment
+                  // Create session from database payment
+                  session = {
+                    id: paymentId,
+                    payment: payment,
+                    createdAt: new Date(payment.createdAt || Date.now()),
+                    status: 'pending' as PaymentOutcome
+                  }
+                  // Store in memory for future requests
+                  testPaymentSessions.set(paymentId, session)
+                }
+              } catch (error) {
+                console.error('Error fetching payment from database:', error)
+              }
+            }
+
             if (!session) {
               return new Response(JSON.stringify({ error: 'Payment session not found' }), {
                 status: 404,
@@ -480,18 +597,23 @@ export const testProvider = (testConfig: TestProviderConfig) => {
       // Generate unique test payment ID
       const testPaymentId = `test_pay_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
 
-      // Create test payment session
-      const session = {
+      // Create test payment session with redirect URL
+      const session: TestPaymentSession = {
         id: testPaymentId,
         payment: { ...payment },
         createdAt: new Date(),
-        status: 'pending' as PaymentOutcome
+        status: 'pending' as PaymentOutcome,
+        redirectUrl: payment.redirectUrl || undefined
       }
 
       testPaymentSessions.set(testPaymentId, session)
 
       // Set provider ID and data
       payment.providerId = testPaymentId
+      // Use custom UI route if specified, otherwise use built-in UI endpoint
+      const paymentUrl = testConfig.customUiRoute
+        ? `${baseUrl}${testConfig.customUiRoute}/${testPaymentId}`
+        : `${baseUrl}/api/payload-billing/test/payment/${testPaymentId}`
       const providerData: ProviderData = {
         raw: {
           id: testPaymentId,
@@ -500,7 +622,7 @@ export const testProvider = (testConfig: TestProviderConfig) => {
           description: payment.description,
           status: 'pending',
           testMode: true,
-          paymentUrl: `${baseUrl}/api/payload-billing/test/payment/${testPaymentId}`,
+          paymentUrl,
           scenarios: scenarios.map(s => ({ id: s.id, name: s.name, description: s.description })),
           methods: Object.entries(PAYMENT_METHODS).map(([key, value]) => ({
             id: key,
@@ -512,6 +634,7 @@ export const testProvider = (testConfig: TestProviderConfig) => {
         provider: 'test'
       }
       payment.providerData = providerData
+      payment.checkoutUrl = paymentUrl
 
       return payment
     },
@@ -599,7 +722,8 @@ function generateTestPaymentUI(
   scenarios: PaymentScenario[],
   uiRoute: string,
   baseUrl: string,
-  testConfig: TestProviderConfig
+  testConfig: TestProviderConfig,
+  redirectUrl: string
 ): string {
   const payment = session.payment
   const testModeIndicators = testConfig.testModeIndicators || {}
@@ -913,9 +1037,9 @@ function generateTestPaymentUI(
 
                 if (result.status === 'paid') {
                     status.className = 'status success';
-                    status.textContent = '✅ Payment successful!';
+                    status.textContent = '✅ Payment successful! Redirecting...';
                     setTimeout(() => {
-                        window.location.href = '${baseUrl}/success';
+                        window.location.href = '${redirectUrl}';
                     }, 2000);
                 } else if (result.status === 'failed' || result.status === 'cancelled' || result.status === 'expired') {
                     status.className = 'status error';

src/providers/utils.ts

@@ -16,7 +16,7 @@ export const webhookResponses = {
     // Log error internally but don't expose details
     if (payload) {
       const logger = createContextLogger(payload, 'Webhook')
-      logger.error('Error:', message)
+      logger.error(`Error: ${message}`)
     } else {
       console.error('[Webhook] Error:', message)
     }
@@ -60,6 +60,7 @@ export async function updatePaymentStatus(
   pluginConfig: BillingPluginConfig
 ): Promise<boolean> {
   const paymentsCollection = extractSlug(pluginConfig.collections?.payments, defaults.paymentsCollection)
+  const logger = createContextLogger(payload, 'Payment Update')
 
   try {
     // First, fetch the current payment to get the current version
@@ -69,41 +70,65 @@ export async function updatePaymentStatus(
     }) as Payment
 
     if (!currentPayment) {
-      const logger = createContextLogger(payload, 'Payment Update')
       logger.error(`Payment ${paymentId} not found`)
       return false
     }
 
     const currentVersion = currentPayment.version || 1
 
-    // Attempt to update with optimistic locking
-    // We'll use a transaction to ensure atomicity
-    const transactionID = await payload.db.beginTransaction()
-
-    if (!transactionID) {
-      const logger = createContextLogger(payload, 'Payment Update')
-      logger.error('Failed to begin transaction')
-      return false
+    // Try to use transactions if supported by the database adapter
+    let transactionID: string | number | null = null
+    try {
+      transactionID = await payload.db.beginTransaction()
+    } catch (error) {
+      // Transaction support may not be available in all database adapters
+      logger.debug('Transactions not supported, falling back to direct update')
     }
 
-    try {
-      // Re-fetch within transaction to ensure consistency
-      const paymentInTransaction = await payload.findByID({
-        collection: paymentsCollection,
-        id: toPayloadId(paymentId),
-        req: { transactionID }
-      }) as Payment
+    if (transactionID) {
+      // Use transactional update with optimistic locking
+      try {
+        // Re-fetch within transaction to ensure consistency
+        const paymentInTransaction = await payload.findByID({
+          collection: paymentsCollection,
+          id: toPayloadId(paymentId),
+          req: { transactionID }
+        }) as Payment
 
-      // Check if version still matches
-      if ((paymentInTransaction.version || 1) !== currentVersion) {
-        // Version conflict detected - payment was modified by another process
-        const logger = createContextLogger(payload, 'Payment Update')
-        logger.warn(`Version conflict for payment ${paymentId} (expected version: ${currentVersion}, got: ${paymentInTransaction.version})`)
+        // Check if version still matches
+        if ((paymentInTransaction.version || 1) !== currentVersion) {
+          // Version conflict detected - payment was modified by another process
+          logger.warn(`Version conflict for payment ${paymentId} (expected version: ${currentVersion}, got: ${paymentInTransaction.version})`)
+          await payload.db.rollbackTransaction(transactionID)
+          return false
+        }
+
+        // Update with new version
+        await payload.update({
+          collection: paymentsCollection,
+          id: toPayloadId(paymentId),
+          data: {
+            status,
+            providerData: {
+              ...providerData,
+              webhookProcessedAt: new Date().toISOString()
+            },
+            version: currentVersion + 1
+          },
+          req: { transactionID }
+        })
+
+        await payload.db.commitTransaction(transactionID)
+        return true
+      } catch (error) {
         await payload.db.rollbackTransaction(transactionID)
-        return false
+        throw error
       }
+    } else {
+      // Fallback: Direct update without transaction support
+      // This is less safe but allows payment updates on databases without transaction support
+      logger.debug('Using direct update without transaction')
 
-      // Update with new version
       await payload.update({
         collection: paymentsCollection,
         id: toPayloadId(paymentId),
@@ -114,19 +139,18 @@ export async function updatePaymentStatus(
             webhookProcessedAt: new Date().toISOString()
           },
           version: currentVersion + 1
-        },
-        req: { transactionID }
+        }
       })
 
-      await payload.db.commitTransaction(transactionID)
       return true
-    } catch (error) {
-      await payload.db.rollbackTransaction(transactionID)
-      throw error
     }
   } catch (error) {
-    const logger = createContextLogger(payload, 'Payment Update')
-    logger.error(`Failed to update payment ${paymentId}:`, error)
+    const errorMessage = error instanceof Error ? error.message : String(error)
+    const errorStack = error instanceof Error ? error.stack : undefined
+    logger.error(`Failed to update payment ${paymentId}: ${errorMessage}`)
+    if (errorStack) {
+      logger.error(`Stack trace: ${errorStack}`)
+    }
     return false
   }
 }
@@ -165,15 +189,22 @@ export function handleWebhookError(
   context?: string,
   payload?: Payload
 ): Response {
-  const message = error instanceof Error ? error.message : 'Unknown error'
+  const message = error instanceof Error ? error.message : String(error)
+  const stack = error instanceof Error ? error.stack : undefined
   const fullContext = context ? `${provider} Webhook - ${context}` : `${provider} Webhook`
 
   // Log detailed error internally for debugging
   if (payload) {
     const logger = createContextLogger(payload, fullContext)
-    logger.error('Error:', error)
+    logger.error(`Error: ${message}`)
+    if (stack) {
+      logger.error(`Stack trace: ${stack}`)
+    }
   } else {
-    console.error(`[${fullContext}] Error:`, error)
+    console.error(`[${fullContext}] Error: ${message}`)
+    if (stack) {
+      console.error(`[${fullContext}] Stack trace:`, stack)
+    }
   }
 
   // Return generic response to avoid information disclosure