create-charcole 2.2.1 → 2.3.0

package/template/js/src/modules/payments/__tests__/payments.routes.test.js

@@ -0,0 +1,256 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import express from 'express'
+import request from 'supertest'
+
+vi.mock('../payments.service.js', () => ({
+  createPayment: vi.fn(),
+  refundPayment: vi.fn(),
+  getPaymentStatus: vi.fn(),
+  processWebhook: vi.fn(),
+}))
+
+vi.mock('../../../utils/logger.js', () => ({
+  logger: {
+    info: vi.fn(),
+    error: vi.fn(),
+    warn: vi.fn(),
+  },
+}))
+
+import paymentsRouter from '../payments.routes.js'
+import * as service from '../payments.service.js'
+
+function buildTestApp() {
+  const app = express()
+  app.use('/payments/webhook', express.raw({ type: 'application/json' }))
+  app.use(express.json())
+  app.use('/payments', paymentsRouter)
+  app.use((err, req, res, next) => {
+    res.status(err.statusCode ?? 500).json({ error: err.message, code: err.code })
+  })
+  return app
+}
+
+let app
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  process.env.PAYMENT_PROVIDER = 'stripe'
+  app = buildTestApp()
+})
+
+afterEach(() => {
+  delete process.env.PAYMENT_PROVIDER
+})
+
+describe('payments.routes', () => {
+  describe('POST /payments/create-intent', () => {
+    it('returns 201 with payment data on valid Stripe request', async () => {
+      const result = {
+        id: 'pi_test',
+        clientSecret: 'secret_abc',
+        status: 'requires_payment_method',
+        amount: 999,
+        currency: 'usd',
+      }
+      service.createPayment.mockResolvedValue(result)
+
+      const response = await request(app)
+        .post('/payments/create-intent')
+        .send({ amount: 999, currency: 'usd' })
+
+      expect(response.status).toBe(201)
+      expect(response.body.data.id).toBe('pi_test')
+      expect(response.body.data.clientSecret).toBe('secret_abc')
+      expect(service.createPayment).toHaveBeenCalledWith({ amount: 999, currency: 'usd', metadata: {} })
+    })
+
+    it('returns 201 with checkoutUrl on valid LemonSqueezy request', async () => {
+      const result = {
+        id: 'ls_test',
+        checkoutUrl: 'https://store.lemonsqueezy.com/checkout/buy',
+        status: 'created',
+        amount: 999,
+        currency: 'usd',
+      }
+      service.createPayment.mockResolvedValue(result)
+
+      const response = await request(app)
+        .post('/payments/create-intent')
+        .send({ amount: 999, currency: 'usd', metadata: { variantId: '12345' } })
+
+      expect(response.status).toBe(201)
+      expect(response.body.data.checkoutUrl).toBe('https://store.lemonsqueezy.com/checkout/buy')
+      expect(service.createPayment).toHaveBeenCalledWith({
+        amount: 999,
+        currency: 'usd',
+        metadata: { variantId: '12345' },
+      })
+    })
+
+    it('returns 400 when amount is missing', async () => {
+      const response = await request(app).post('/payments/create-intent').send({ currency: 'usd' })
+
+      expect(response.status).toBe(400)
+      expect(response.body.error).toBeDefined()
+    })
+
+    it('returns 400 when amount is a float', async () => {
+      const response = await request(app).post('/payments/create-intent').send({ amount: 9.99, currency: 'usd' })
+
+      expect(response.status).toBe(400)
+      expect(response.body.error).toBeDefined()
+    })
+
+    it('returns 400 when currency is wrong length', async () => {
+      const response = await request(app).post('/payments/create-intent').send({ amount: 100, currency: 'us' })
+
+      expect(response.status).toBe(400)
+      expect(response.body.error).toBeDefined()
+    })
+
+    it('returns 500 when service throws', async () => {
+      const error = new Error('service failure')
+      error.statusCode = 500
+      service.createPayment.mockRejectedValue(error)
+
+      const response = await request(app).post('/payments/create-intent').send({ amount: 999, currency: 'usd' })
+
+      expect(response.status).toBe(500)
+      expect(response.body.error).toBe('service failure')
+    })
+  })
+
+  describe('POST /payments/refund', () => {
+    it('returns 200 with refund data on valid request', async () => {
+      const result = { id: 're_123', status: 'succeeded', amount: 500 }
+      service.refundPayment.mockResolvedValue(result)
+
+      const response = await request(app).post('/payments/refund').send({ paymentId: 'pi_123', amount: 500 })
+
+      expect(response.status).toBe(200)
+      expect(response.body.data).toEqual(result)
+      expect(service.refundPayment).toHaveBeenCalledWith({ paymentId: 'pi_123', amount: 500 })
+    })
+
+    it('returns 200 when amount is omitted (full refund)', async () => {
+      const result = { id: 're_124', status: 'succeeded', amount: 0 }
+      service.refundPayment.mockResolvedValue(result)
+
+      const response = await request(app).post('/payments/refund').send({ paymentId: 'pi_123' })
+
+      expect(response.status).toBe(200)
+      expect(response.body.data).toEqual(result)
+      expect(service.refundPayment).toHaveBeenCalledWith({ paymentId: 'pi_123', amount: undefined })
+    })
+
+    it('returns 400 when paymentId is missing', async () => {
+      const response = await request(app).post('/payments/refund').send({ amount: 500 })
+
+      expect(response.status).toBe(400)
+      expect(response.body.error).toBeDefined()
+    })
+
+    it('returns error status when service rejects', async () => {
+      const error = new Error('refund failed')
+      error.statusCode = 500
+      service.refundPayment.mockRejectedValue(error)
+
+      const response = await request(app).post('/payments/refund').send({ paymentId: 'pi_123', amount: 500 })
+
+      expect(response.status).toBe(500)
+      expect(response.body.error).toBe('refund failed')
+    })
+  })
+
+  describe('GET /payments/status/:paymentId', () => {
+    it('returns 200 with payment status for a valid paymentId', async () => {
+      const result = { id: 'pi_test_123', status: 'paid', amount: 999, currency: 'usd', metadata: {} }
+      service.getPaymentStatus.mockResolvedValue(result)
+
+      const response = await request(app).get('/payments/status/pi_test_123')
+
+      expect(response.status).toBe(200)
+      expect(response.body.data.status).toBe('paid')
+      expect(service.getPaymentStatus).toHaveBeenCalledWith('pi_test_123')
+    })
+
+    it('passes the paymentId from URL params to service', async () => {
+      const result = { id: 'pi_specific_id', status: 'paid', amount: 999, currency: 'usd', metadata: {} }
+      service.getPaymentStatus.mockResolvedValue(result)
+
+      const response = await request(app).get('/payments/status/pi_specific_id')
+
+      expect(response.status).toBe(200)
+      expect(service.getPaymentStatus).toHaveBeenCalledWith('pi_specific_id')
+      expect(response.body.data.id).toBe('pi_specific_id')
+    })
+
+    it('returns error status when service rejects', async () => {
+      const error = new Error('status error')
+      error.statusCode = 500
+      service.getPaymentStatus.mockRejectedValue(error)
+
+      const response = await request(app).get('/payments/status/pi_error')
+
+      expect(response.status).toBe(500)
+      expect(response.body.error).toBe('status error')
+    })
+  })
+
+  describe('POST /payments/webhook', () => {
+    it('returns 200 { received: true } for valid Stripe webhook', async () => {
+      service.processWebhook.mockResolvedValue({ event: 'payment_intent.succeeded', data: {}, duplicate: false })
+
+      const response = await request(app)
+        .post('/payments/webhook')
+        .set('Content-Type', 'application/json')
+        .set('stripe-signature', 'stripe-sig')
+        .send(Buffer.from('{"id":"evt_test_001"}'))
+
+      expect(response.status).toBe(200)
+      expect(response.body.received).toBe(true)
+      expect(service.processWebhook).toHaveBeenCalled()
+      const rawArg = service.processWebhook.mock.calls[0][0]
+      expect(Buffer.isBuffer(rawArg)).toBe(true)
+      expect(rawArg.toString()).toBe('{"id":"evt_test_001"}')
+    })
+
+    it('returns 200 { received: true, duplicate: true } for duplicate event', async () => {
+      service.processWebhook.mockResolvedValue({ event: 'payment_intent.succeeded', data: {}, duplicate: true })
+
+      const response = await request(app)
+        .post('/payments/webhook')
+        .set('Content-Type', 'application/json')
+        .set('stripe-signature', 'stripe-sig')
+        .send(Buffer.from('{"id":"evt_test_002"}'))
+
+      expect(response.status).toBe(200)
+      expect(response.body.received).toBe(true)
+      expect(response.body.duplicate).toBe(true)
+    })
+
+    it('returns 400 when signature header is missing', async () => {
+      const response = await request(app)
+        .post('/payments/webhook')
+        .set('Content-Type', 'application/json')
+        .send(Buffer.from('{"id":"evt_test_003"}'))
+
+      expect(response.status).toBe(400)
+      expect(response.body.error).toBe('Missing webhook signature header')
+    })
+
+    it('does NOT require Authorization header', async () => {
+      service.processWebhook.mockResolvedValue({ event: 'payment_intent.succeeded', data: {}, duplicate: false })
+
+      const response = await request(app)
+        .post('/payments/webhook')
+        .set('Content-Type', 'application/json')
+        .set('stripe-signature', 'stripe-sig')
+        .send(Buffer.from('{"id":"evt_test_004"}'))
+
+      expect(response.status).toBe(200)
+      expect(response.body.received).toBe(true)
+    })
+  })
+})

package/template/js/src/modules/payments/__tests__/payments.schemas.test.js

@@ -0,0 +1,94 @@
+import { describe, it, expect } from 'vitest'
+import { createPaymentSchema, refundPaymentSchema } from '../payments.schemas.js'
+
+describe('createPaymentSchema', () => {
+  it('parses valid input correctly', () => {
+    const result = createPaymentSchema.parse({ amount: 999, currency: 'usd' })
+
+    expect(result).toEqual({ amount: 999, currency: 'usd', metadata: {} })
+  })
+
+  it('lowercases currency automatically', () => {
+    const result = createPaymentSchema.parse({ amount: 100, currency: 'USD' })
+
+    expect(result.currency).toBe('usd')
+  })
+
+  it('rejects non-integer amount', () => {
+    expect(() => createPaymentSchema.parse({ amount: 9.99, currency: 'usd' })).toThrow()
+  })
+
+  it('rejects negative amount', () => {
+    expect(() => createPaymentSchema.parse({ amount: -100, currency: 'usd' })).toThrow()
+  })
+
+  it('rejects zero amount', () => {
+    expect(() => createPaymentSchema.parse({ amount: 0, currency: 'usd' })).toThrow()
+  })
+
+  it('rejects amount over maximum', () => {
+    expect(() => createPaymentSchema.parse({ amount: 100000000, currency: 'usd' })).toThrow()
+  })
+
+  it('rejects currency longer than 3 chars', () => {
+    expect(() => createPaymentSchema.parse({ amount: 100, currency: 'usdx' })).toThrow()
+  })
+
+  it('rejects currency shorter than 3 chars', () => {
+    expect(() => createPaymentSchema.parse({ amount: 100, currency: 'us' })).toThrow()
+  })
+
+  it('rejects missing amount', () => {
+    expect(() => createPaymentSchema.parse({ currency: 'usd' })).toThrow(/amount is required/)
+  })
+
+  it('rejects missing currency', () => {
+    expect(() => createPaymentSchema.parse({ amount: 100 })).toThrow(/currency is required/)
+  })
+
+  it('accepts metadata as key-value string pairs', () => {
+    const result = createPaymentSchema.parse({
+      amount: 100,
+      currency: 'usd',
+      metadata: { orderId: '123', userId: '456' },
+    })
+
+    expect(result.metadata).toEqual({ orderId: '123', userId: '456' })
+  })
+
+  it('rejects metadata with non-string values', () => {
+    expect(() =>
+      createPaymentSchema.parse({ amount: 100, currency: 'usd', metadata: { count: 5 } }),
+    ).toThrow()
+  })
+})
+
+describe('refundPaymentSchema', () => {
+  it('parses paymentId correctly', () => {
+    const result = refundPaymentSchema.parse({ paymentId: 'pi_abc123' })
+
+    expect(result).toEqual({ paymentId: 'pi_abc123', amount: undefined })
+  })
+
+  it('accepts optional partial refund amount', () => {
+    const result = refundPaymentSchema.parse({ paymentId: 'pi_abc123', amount: 500 })
+
+    expect(result.amount).toBe(500)
+  })
+
+  it('rejects empty paymentId', () => {
+    expect(() => refundPaymentSchema.parse({ paymentId: '' })).toThrow()
+  })
+
+  it('rejects missing paymentId', () => {
+    expect(() => refundPaymentSchema.parse({})).toThrow(/paymentId is required/)
+  })
+
+  it('rejects non-integer refund amount', () => {
+    expect(() => refundPaymentSchema.parse({ paymentId: 'pi_abc', amount: 9.99 })).toThrow()
+  })
+
+  it('rejects negative refund amount', () => {
+    expect(() => refundPaymentSchema.parse({ paymentId: 'pi_abc', amount: -100 })).toThrow()
+  })
+})

package/template/js/src/modules/payments/__tests__/payments.service.test.js

@@ -0,0 +1,141 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+vi.mock('../payments.adapter.js', () => ({
+  getAdapter: vi.fn(),
+  resetAdapter: vi.fn(),
+}))
+
+import { getAdapter } from '../payments.adapter.js'
+import * as service from '../payments.service.js'
+
+beforeEach(() => {
+  vi.clearAllMocks()
+})
+
+describe('payments.service', () => {
+  it('delegates to adapter.createPayment and returns its result', async () => {
+    const mockResult = {
+      id: 'pi_test_123',
+      clientSecret: 'secret_abc',
+      status: 'requires_payment_method',
+      amount: 999,
+      currency: 'usd',
+      metadata: {},
+    }
+    const adapter = { createPayment: vi.fn().mockResolvedValue(mockResult) }
+    getAdapter.mockReturnValue(adapter)
+
+    const result = await service.createPayment({ amount: 999, currency: 'usd' })
+
+    expect(adapter.createPayment).toHaveBeenCalledWith({ amount: 999, currency: 'usd' })
+    expect(result).toEqual(mockResult)
+  })
+
+  it('propagates errors from adapter.createPayment', async () => {
+    const error = new Error('payment failed')
+    const adapter = { createPayment: vi.fn().mockRejectedValue(error) }
+    getAdapter.mockReturnValue(adapter)
+
+    await expect(service.createPayment({ amount: 999, currency: 'usd' })).rejects.toThrow(error)
+  })
+
+  it('delegates to adapter.refundPayment with paymentId and amount', async () => {
+    const mockResult = { id: 're_test_123', status: 'succeeded', amount: 500 }
+    const adapter = { refundPayment: vi.fn().mockResolvedValue(mockResult) }
+    getAdapter.mockReturnValue(adapter)
+
+    const result = await service.refundPayment({ paymentId: 'pi_123', amount: 500 })
+
+    expect(adapter.refundPayment).toHaveBeenCalledWith({ paymentId: 'pi_123', amount: 500 })
+    expect(result).toEqual(mockResult)
+  })
+
+  it('delegates to adapter.refundPayment without amount when not provided', async () => {
+    const mockResult = { id: 're_test_124', status: 'succeeded', amount: 0 }
+    const adapter = { refundPayment: vi.fn().mockResolvedValue(mockResult) }
+    getAdapter.mockReturnValue(adapter)
+
+    const result = await service.refundPayment({ paymentId: 'pi_123' })
+
+    expect(adapter.refundPayment).toHaveBeenCalledWith({ paymentId: 'pi_123', amount: undefined })
+    expect(result).toEqual(mockResult)
+  })
+
+  it('propagates adapter errors from refundPayment', async () => {
+    const error = new Error('refund failed')
+    const adapter = { refundPayment: vi.fn().mockRejectedValue(error) }
+    getAdapter.mockReturnValue(adapter)
+
+    await expect(service.refundPayment({ paymentId: 'pi_123', amount: 500 })).rejects.toThrow(error)
+  })
+
+  it('delegates to adapter.getPaymentStatus with the paymentId string', async () => {
+    const mockResult = { id: 'pi_123', status: 'paid', amount: 999, currency: 'usd', metadata: {} }
+    const adapter = { getPaymentStatus: vi.fn().mockResolvedValue(mockResult) }
+    getAdapter.mockReturnValue(adapter)
+
+    const result = await service.getPaymentStatus('pi_123')
+
+    expect(adapter.getPaymentStatus).toHaveBeenCalledWith('pi_123')
+    expect(result).toEqual(mockResult)
+  })
+
+  it('propagates adapter errors from getPaymentStatus', async () => {
+    const error = new Error('status error')
+    const adapter = { getPaymentStatus: vi.fn().mockRejectedValue(error) }
+    getAdapter.mockReturnValue(adapter)
+
+    await expect(service.getPaymentStatus('pi_123')).rejects.toThrow(error)
+  })
+
+  it('calls adapter.verifyWebhook and returns duplicate:false on first call', async () => {
+    const adapter = {
+      verifyWebhook: vi.fn().mockResolvedValue({ event: 'payment_intent.succeeded', data: { id: 'evt_001' } }),
+    }
+    getAdapter.mockReturnValue(adapter)
+
+    const result = await service.processWebhook(Buffer.from('{"id":"evt_001"}'), 'sig')
+
+    expect(adapter.verifyWebhook).toHaveBeenCalledWith(Buffer.from('{"id":"evt_001"}'), 'sig')
+    expect(result.duplicate).toBe(false)
+    expect(result.event).toBe('payment_intent.succeeded')
+  })
+
+  it('returns duplicate:true on second call with same event id', async () => {
+    const event = { event: 'payment_intent.succeeded', data: { id: 'evt_002' } }
+    const adapter = {
+      verifyWebhook: vi.fn().mockResolvedValue(event),
+    }
+    getAdapter.mockReturnValue(adapter)
+
+    const first = await service.processWebhook(Buffer.from('{"id":"evt_002"}'), 'sig')
+    const second = await service.processWebhook(Buffer.from('{"id":"evt_002"}'), 'sig')
+
+    expect(first.duplicate).toBe(false)
+    expect(second.duplicate).toBe(true)
+    expect(adapter.verifyWebhook).toHaveBeenCalledTimes(2)
+  })
+
+  it('treats events without id as unique using event+timestamp', async () => {
+    const adapter = {
+      verifyWebhook: vi.fn().mockResolvedValue({ event: 'some_event', data: {} }),
+    }
+    getAdapter.mockReturnValue(adapter)
+
+    const first = await service.processWebhook(Buffer.from('{"id":"evt_none_1"}'), 'sig')
+    await new Promise((resolve) => setTimeout(resolve, 1))
+    const second = await service.processWebhook(Buffer.from('{"id":"evt_none_2"}'), 'sig')
+
+    expect(first.duplicate).toBe(false)
+    expect(second.duplicate).toBe(false)
+    expect(adapter.verifyWebhook).toHaveBeenCalledTimes(2)
+  })
+
+  it('propagates PaymentError WEBHOOK_INVALID from adapter', async () => {
+    const error = new Error('bad sig')
+    const adapter = { verifyWebhook: vi.fn().mockRejectedValue(error) }
+    getAdapter.mockReturnValue(adapter)
+
+    await expect(service.processWebhook(Buffer.from('{"id":"evt_003"}'), 'sig')).rejects.toThrow(error)
+  })
+})

package/template/js/src/modules/payments/package.json

@@ -0,0 +1,7 @@
+{
+  "dependencies": {
+    "@charcoles/payments": "^1.0.1",
+    "stripe": "^14.0.0",
+    "@lemonsqueezy/lemonsqueezy.js": "^4.0.0"
+  }
+}

package/template/js/src/modules/payments/payments.adapter.js

@@ -0,0 +1,47 @@
+import { env } from "../../config/env.js";
+import {
+  StripeAdapter,
+  LemonSqueezyAdapter,
+  PaymentError,
+} from "@charcoles/payments";
+
+let adapter = null;
+
+export function getAdapter() {
+  if (adapter) return adapter;
+
+  const provider = env.PAYMENT_PROVIDER;
+
+  if (!provider) {
+    throw new PaymentError(
+      'PAYMENT_PROVIDER env var is not set. Set it to "stripe" or "lemonsqueezy".',
+      "PROVIDER_NOT_CONFIGURED",
+      500,
+    );
+  }
+
+  if (provider === "stripe") {
+    adapter = new StripeAdapter({
+      secretKey: env.STRIPE_SECRET_KEY,
+      webhookSecret: env.STRIPE_WEBHOOK_SECRET,
+    });
+  } else if (provider === "lemonsqueezy") {
+    adapter = new LemonSqueezyAdapter({
+      apiKey: env.LEMONSQUEEZY_API_KEY,
+      webhookSecret: env.LEMONSQUEEZY_WEBHOOK_SECRET,
+      storeId: env.LEMONSQUEEZY_STORE_ID,
+    });
+  } else {
+    throw new PaymentError(
+      `Unknown PAYMENT_PROVIDER: "${provider}". Use "stripe" or "lemonsqueezy".`,
+      "CONFIG_ERROR",
+      500,
+    );
+  }
+
+  return adapter;
+}
+
+export function resetAdapter() {
+  adapter = null;
+}

package/template/js/src/modules/payments/payments.constants.js

@@ -0,0 +1,20 @@
+export const PAYMENT_PROVIDERS = {
+  STRIPE: "stripe",
+  LEMONSQUEEZY: "lemonsqueezy",
+};
+
+export const PAYMENT_EVENTS = {
+  // Stripe events
+  STRIPE_PAYMENT_SUCCEEDED: "payment_intent.succeeded",
+  STRIPE_PAYMENT_FAILED: "payment_intent.payment_failed",
+  STRIPE_REFUND_CREATED: "charge.refunded",
+  // LemonSqueezy events
+  LS_ORDER_CREATED: "order_created",
+  LS_ORDER_REFUNDED: "order_refunded",
+  LS_SUBSCRIPTION_CANCELLED: "subscription_cancelled",
+};
+
+export const WEBHOOK_HEADERS = {
+  stripe: "stripe-signature",
+  lemonsqueezy: "x-signature",
+};

package/template/js/src/modules/payments/payments.controller.js

@@ -0,0 +1,85 @@
+import * as paymentsService from "./payments.service.js";
+import { sendSuccess } from "../../utils/response.js";
+import {
+  createPaymentSchema,
+  refundPaymentSchema,
+} from "./payments.schemas.js";
+import { WEBHOOK_HEADERS, PAYMENT_EVENTS } from "./payments.constants.js";
+import { logger } from "../../utils/logger.js";
+
+export const createPayment = async (req, res, next) => {
+  try {
+    const validated = createPaymentSchema.parse(req.body);
+    const result = await paymentsService.createPayment(validated);
+    sendSuccess(res, result, 201);
+  } catch (err) {
+    next(err);
+  }
+};
+
+export const refundPayment = async (req, res, next) => {
+  try {
+    const validated = refundPaymentSchema.parse(req.body);
+    const result = await paymentsService.refundPayment(validated);
+    sendSuccess(res, result);
+  } catch (err) {
+    next(err);
+  }
+};
+
+export const getPaymentStatus = async (req, res, next) => {
+  try {
+    const result = await paymentsService.getPaymentStatus(req.params.paymentId);
+    sendSuccess(res, result);
+  } catch (err) {
+    next(err);
+  }
+};
+
+export const handleWebhook = async (req, res, next) => {
+  try {
+    const provider = process.env.PAYMENT_PROVIDER;
+    const headerName = WEBHOOK_HEADERS[provider];
+    const signature = req.headers[headerName];
+
+    if (!signature) {
+      return res
+        .status(400)
+        .json({ error: "Missing webhook signature header" });
+    }
+
+    const result = await paymentsService.processWebhook(req.body, signature);
+
+    if (result.duplicate) {
+      logger.info(
+        `Duplicate webhook event received and ignored: ${result.event}`,
+      );
+      return res.status(200).json({ received: true, duplicate: true });
+    }
+
+    logger.info(`Webhook event received: ${result.event}`);
+
+    switch (result.event) {
+      case PAYMENT_EVENTS.STRIPE_PAYMENT_SUCCEEDED:
+      case PAYMENT_EVENTS.LS_ORDER_CREATED:
+        logger.info("Payment confirmed. Add your fulfillment logic here.");
+        break;
+
+      case PAYMENT_EVENTS.STRIPE_PAYMENT_FAILED:
+        logger.warn("Payment failed. Add your failure handling logic here.");
+        break;
+
+      case PAYMENT_EVENTS.LS_ORDER_REFUNDED:
+      case PAYMENT_EVENTS.STRIPE_REFUND_CREATED:
+        logger.info("Refund processed. Add your refund handling logic here.");
+        break;
+
+      default:
+        logger.info(`Unhandled webhook event: ${result.event}`);
+    }
+
+    res.status(200).json({ received: true });
+  } catch (err) {
+    next(err);
+  }
+};