Bun Adaptor

Pelajari cara mengintegrasikan <CardGroup cols={2}> dengan proyek server Bun Anda menggunakan Bun Adaptor kami. Mencakup checkout, portal pelanggan, webhook, dan penyiapan environment yang aman.

Checkout Handler

Integrasikan checkout Dodo Payments ke server Bun Anda.

Customer Portal

Izinkan pelanggan mengelola langganan dan detail mereka.

Webhooks

Terima dan proses event webhook Dodo Payments.

​

Instalasi

1. Install the package

   Jalankan perintah berikut di root proyek Anda:

   bun add @dodopayments/bun
   
2. Set up environment variables

   Buat file .env di root proyek Anda:

   DODO_PAYMENTS_API_KEY=your-api-key
   DODO_PAYMENTS_WEBHOOK_KEY=your-webhook-secret
   DODO_PAYMENTS_ENVIRONMENT="test_mode" or "live_mode"
   DODO_PAYMENTS_RETURN_URL=your-return-url
   

   Jangan pernah commit file .env atau secrets Anda ke version control.

​

Contoh Route Handler

Semua contoh mengasumsikan Anda menggunakan server native Bun dengan Bun.serve().

Checkout Handler

Gunakan handler ini untuk mengintegrasikan checkout Dodo Payments ke server Bun Anda. Mendukung alur pembayaran statis (GET), dinamis (POST), dan sesi (POST).

Bun Server Handler

import { Checkout } from '@dodopayments/bun';

const staticCheckoutHandler = Checkout({
    bearerToken: process.env.DODO_PAYMENTS_API_KEY,
    returnUrl: process.env.DODO_PAYMENTS_RETURN_URL,
    environment: process.env.DODO_PAYMENTS_ENVIRONMENT,
    type: "static"
});

const sessionCheckoutHandler = Checkout({
    bearerToken: process.env.DODO_PAYMENTS_API_KEY,
    returnUrl: process.env.DODO_PAYMENTS_RETURN_URL,
    environment: process.env.DODO_PAYMENTS_ENVIRONMENT,
    type: "session"
});

const dynamicCheckoutHandler = Checkout({
    bearerToken: process.env.DODO_PAYMENTS_API_KEY,
    returnUrl: process.env.DODO_PAYMENTS_RETURN_URL,
    environment: process.env.DODO_PAYMENTS_ENVIRONMENT,
    type: "dynamic"
});

Bun.serve({
  port: 3000,
  fetch(request) {
    const url = new URL(request.url);
    
    if (url.pathname === "/api/checkout") {
      if (request.method === "GET") {
        return staticCheckoutHandler(request);
      }
      if (request.method === "POST") {
        return sessionCheckoutHandler(request);
        // or return dynamicCheckoutHandler(request);
      }
    }
    
    return new Response("Not Found", { status: 404 });
  },
});

Static Checkout Curl example

curl --request GET \
--url 'https://example.com/api/checkout?productId=pdt_xxx' \
--header 'User-Agent: insomnia/11.2.0' \
--cookie mode=test

Dynamic Checkout Curl example

curl --request POST \
--url https://example.com/api/checkout \
--header 'Content-Type: application/json' \
--header 'User-Agent: insomnia/11.2.0' \
--cookie mode=test \
--data '{
"billing": {
  "city": "Texas",
  "country": "US",
  "state": "Texas",
  "street": "56, hhh",
  "zipcode": "560000"
},
"customer": {
  "email": "[e-mail]",
  	"name": "test"
},
"metadata": {},
"payment_link": true,
  "product_id": "pdt_xxx",
  "quantity": 1,
  "billing_currency": "USD",
  "discount_codes": ["IKHZ23M9GQ"],
  "return_url": "https://example.com",
  "trial_period_days": 10
}'

Checkout Session Curl example

curl --request POST \
--url https://example.com/api/checkout \
--header 'Content-Type: application/json' \
--header 'User-Agent: insomnia/11.2.0' \
--cookie mode=test \
--data '{
"product_cart": [
  {
    "product_id": "pdt_xxx",
    "quantity": 1
  }
],
"customer": {
  "email": "[e-mail]",
  "name": "test"
},
"return_url": "https://example.com/success"
}'

Customer Portal Handler

Gunakan handler ini agar pelanggan dapat mengelola langganan dan detail mereka melalui customer portal Dodo Payments.

Bun Server Handler

import { CustomerPortal } from "@dodopayments/bun";

const customerPortalHandler = CustomerPortal({
  bearerToken: process.env.DODO_PAYMENTS_API_KEY,
  environment: process.env.DODO_PAYMENTS_ENVIRONMENT,
});

Bun.serve({
  port: 3000,
  fetch(request) {
    const url = new URL(request.url);
    
    if (url.pathname === "/api/customer-portal" && request.method === "GET") {
      return customerPortalHandler(request);
    }
    
    return new Response("Not Found", { status: 404 });
  },
});

Customer Portal Curl example

curl --request GET \
--url 'https://example.com/api/customer-portal?customer_id=cus_123&send_email=true' \
--header 'User-Agent: insomnia/11.2.0' \
--cookie mode=test

Webhook Handler

Gunakan handler ini untuk menerima dan memproses event webhook Dodo Payments dengan aman di server Bun Anda.

Bun Server Handler

import { Webhooks } from "@dodopayments/bun";

const webhookHandler = Webhooks({
  webhookKey: process.env.DODO_PAYMENTS_WEBHOOK_KEY,
  onPayload: async (payload) => {
    // handle the payload
  },
  // ... other event handlers for granular control
});

Bun.serve({
  port: 3000,
  fetch(request) {
    const url = new URL(request.url);
    
    if (url.pathname === "/api/webhook/dodo-payments" && request.method === "POST") {
      return webhookHandler(request);
    }
    
    return new Response("Not Found", { status: 404 });
  },
});

​

Checkout Route Handler

Dodo Payments mendukung tiga jenis alur pembayaran untuk mengintegrasikan pembayaran ke situs web Anda; adaptor ini mendukung semua jenis alur pembayaran.

• Payment Links Statis: URL yang dapat langsung dibagikan untuk pengumpulan pembayaran cepat tanpa kode.
• Payment Links Dinamis: Buat payment links secara terprogram dengan detail khusus menggunakan API atau SDK.
• Checkout Sessions: Buat pengalaman checkout yang aman dan dapat disesuaikan dengan keranjang produk serta detail pelanggan yang telah dikonfigurasi sebelumnya.

Static Checkout (GET)

​

Query Parameters yang Didukung

productId · string · wajib

Identifier produk (misalnya, ?productId=pdt_xxx).

quantity · integer

Jumlah produk.

fullName · string

Nama lengkap pelanggan.

firstName · string

Nama depan pelanggan.

lastName · string

Nama belakang pelanggan.

email · string

Alamat email pelanggan.

country · string

Negara pelanggan.

addressLine · string

Baris alamat pelanggan.

city · string

Kota pelanggan.

state · string

Negara bagian/provinsi pelanggan.

zipCode · string

Kode pos pelanggan.

disableFullName · boolean

Nonaktifkan field nama lengkap.

disableFirstName · boolean

Nonaktifkan field nama depan.

disableLastName · boolean

Nonaktifkan field nama belakang.

disableEmail · boolean

Nonaktifkan field email.

disableCountry · boolean

Nonaktifkan field negara.

disableAddressLine · boolean

Nonaktifkan field baris alamat.

disableCity · boolean

Nonaktifkan field kota.

disableState · boolean

Nonaktifkan field negara bagian.

disableZipCode · boolean

Nonaktifkan field kode pos.

paymentCurrency · string

Tentukan mata uang pembayaran (misalnya, USD).

showCurrencySelector · boolean

Tampilkan pemilih mata uang.

paymentAmount · integer

Tentukan jumlah pembayaran (misalnya, 1000 untuk $10.00).

showDiscounts · boolean

Tampilkan field diskon.

metadata_* · string

Query parameter apa pun yang diawali metadata_ akan diteruskan sebagai metadata.

Jika productId tidak ada, handler mengembalikan respons 400. Query parameters yang tidak valid juga menghasilkan respons 400.

​

Format Respons

Checkout statis mengembalikan respons JSON dengan URL checkout:

{
  "checkout_url": "https://checkout.dodopayments.com/..."
}

Dynamic Checkout (POST)

• Kirim parameter sebagai body JSON dalam request POST.
• Mendukung pembayaran satu kali dan berulang.
• Untuk daftar lengkap field body POST yang didukung, lihat:
  • Request body untuk One Time Payment Product
  • Request body untuk Subscription Product

​

Format Respons

Checkout dinamis mengembalikan respons JSON dengan URL checkout:

{
  "checkout_url": "https://checkout.dodopayments.com/..."
}

Checkout Sessions (POST)

Checkout sessions menyediakan pengalaman checkout hosted yang lebih aman dan menangani alur pembayaran lengkap untuk pembelian satu kali maupun langganan dengan kontrol kustomisasi penuh.

Lihat Panduan Integrasi Checkout Sessions untuk detail lebih lanjut dan daftar lengkap field yang didukung.

​

Format Respons

Checkout sessions mengembalikan respons JSON dengan URL checkout:

{
  "checkout_url": "https://checkout.dodopayments.com/session/..."
}

​

Customer Portal Route Handler

Customer Portal Route Handler memungkinkan Anda mengintegrasikan customer portal Dodo Payments ke aplikasi server Bun Anda dengan lancar.

​

Query Parameters

customer_id · string · wajib

ID pelanggan untuk sesi portal (misalnya, ?customer_id=cus_123).

send_email · boolean

Jika diatur ke true, email berisi tautan portal akan dikirim kepada pelanggan.

Mengembalikan 400 jika customer_id tidak ada.

​

Webhook Route Handler

• Method: Hanya request POST yang didukung. Method lain mengembalikan 405.
• Signature Verification: Memverifikasi signature webhook menggunakan webhookKey. Mengembalikan 401 jika verifikasi gagal.
• Payload Validation: Divalidasi dengan Zod. Mengembalikan 400 untuk payload yang tidak valid.
• Error Handling:
  • 401: Signature tidak valid
  • 400: Payload tidak valid
  • 500: Error internal selama verifikasi
• Event Routing: Memanggil event handler yang sesuai berdasarkan tipe payload.

​

Event Handler Webhook yang Didukung

Typescript

onPayload?: (payload: WebhookPayload) => Promise<void>;
onPaymentSucceeded?: (payload: WebhookPayload) => Promise<void>;
onPaymentFailed?: (payload: WebhookPayload) => Promise<void>;
onPaymentProcessing?: (payload: WebhookPayload) => Promise<void>;
onPaymentCancelled?: (payload: WebhookPayload) => Promise<void>;
onRefundSucceeded?: (payload: WebhookPayload) => Promise<void>;
onRefundFailed?: (payload: WebhookPayload) => Promise<void>;
onDisputeOpened?: (payload: WebhookPayload) => Promise<void>;
onDisputeExpired?: (payload: WebhookPayload) => Promise<void>;
onDisputeAccepted?: (payload: WebhookPayload) => Promise<void>;
onDisputeCancelled?: (payload: WebhookPayload) => Promise<void>;
onDisputeChallenged?: (payload: WebhookPayload) => Promise<void>;
onDisputeWon?: (payload: WebhookPayload) => Promise<void>;
onDisputeLost?: (payload: WebhookPayload) => Promise<void>;
onSubscriptionActive?: (payload: WebhookPayload) => Promise<void>;
onSubscriptionOnHold?: (payload: WebhookPayload) => Promise<void>;
onSubscriptionRenewed?: (payload: WebhookPayload) => Promise<void>;
onSubscriptionPlanChanged?: (payload: WebhookPayload) => Promise<void>;
onSubscriptionCancelled?: (payload: WebhookPayload) => Promise<void>;
onSubscriptionFailed?: (payload: WebhookPayload) => Promise<void>;
onSubscriptionExpired?: (payload: WebhookPayload) => Promise<void>;
onSubscriptionUpdated?: (payload: WebhookPayload) => Promise<void>;
onLicenseKeyCreated?: (payload: WebhookPayload) => Promise<void>;
onAbandonedCheckoutDetected?: (payload: WebhookPayload) => Promise<void>;
onAbandonedCheckoutRecovered?: (payload: WebhookPayload) => Promise<void>;
onDunningStarted?: (payload: WebhookPayload) => Promise<void>;
onDunningRecovered?: (payload: WebhookPayload) => Promise<void>;
onCreditAdded?: (payload: WebhookPayload) => Promise<void>;
onCreditDeducted?: (payload: WebhookPayload) => Promise<void>;
onCreditExpired?: (payload: WebhookPayload) => Promise<void>;
onCreditRolledOver?: (payload: WebhookPayload) => Promise<void>;
onCreditRolloverForfeited?: (payload: WebhookPayload) => Promise<void>;
onCreditOverageCharged?: (payload: WebhookPayload) => Promise<void>;
onCreditManualAdjustment?: (payload: WebhookPayload) => Promise<void>;
onCreditBalanceLow?: (payload: WebhookPayload) => Promise<void>;

---

​

Prompt untuk LLM

You are an expert Bun developer assistant. Your task is to guide a user through integrating the @dodopayments/bun adapter into their existing Bun project.

The @dodopayments/bun adapter provides handlers for Dodo Payments' Checkout, Customer Portal, and Webhook functionalities, designed for Bun's native server with Bun.serve().

First, install the necessary package:

bun add @dodopayments/bun

Here's how you should structure your response:

    Ask the user which functionalities they want to integrate.

"Which parts of the @dodopayments/bun adapter would you like to integrate into your project? You can choose one or more of the following:
1. Checkout (static, dynamic, or session-based)
2. Customer Portal
3. Webhooks"

    Based on the user's selection, provide step-by-step integration instructions.

For each selected functionality, show:

    The environment variables required
    The exact code to add to their server file
    Where to place the code in their Bun.serve() configuration

Provide complete, working examples that the user can copy and paste directly into their project.

    Environment Variables Setup

Always include instructions for setting up the .env file:

DODO_PAYMENTS_API_KEY=your-api-key
DODO_PAYMENTS_WEBHOOK_KEY=your-webhook-secret
DODO_PAYMENTS_ENVIRONMENT="test_mode" or "live_mode"
DODO_PAYMENTS_RETURN_URL=your-return-url

Remind the user to never commit their .env file to version control.

    For Checkout Integration

If the user selects Checkout, ask which type they need:

    Static checkout (GET requests with query parameters)
    Dynamic checkout (POST requests with JSON body)
    Checkout sessions (POST requests with product cart)

Provide the appropriate handler code for their selection.

    For Customer Portal Integration

Provide a complete example showing how to integrate the customer portal handler into their Bun server.

    For Webhook Integration

Provide a complete example showing how to integrate the webhook handler with available event handlers for granular control.

    Full Example

If the user wants to integrate all three functionalities, provide a complete Bun server example that combines all handlers.

```typescript
import { Checkout, CustomerPortal, Webhooks } from "@dodopayments/bun";

const staticCheckoutHandler = Checkout({
  bearerToken: process.env.DODO_PAYMENTS_API_KEY,
  returnUrl: process.env.DODO_PAYMENTS_RETURN_URL,
  environment: process.env.DODO_PAYMENTS_ENVIRONMENT,
  type: "static",
});

const sessionCheckoutHandler = Checkout({
  bearerToken: process.env.DODO_PAYMENTS_API_KEY,
  returnUrl: process.env.DODO_PAYMENTS_RETURN_URL,
  environment: process.env.DODO_PAYMENTS_ENVIRONMENT,
  type: "session",
});

const customerPortalHandler = CustomerPortal({
  bearerToken: process.env.DODO_PAYMENTS_API_KEY,
  environment: process.env.DODO_PAYMENTS_ENVIRONMENT,
});

const webhookHandler = Webhooks({
  webhookKey: process.env.DODO_PAYMENTS_WEBHOOK_KEY,
  onPaymentSucceeded: async (payload) => {
    console.log("Payment succeeded:", payload);
    // Your business logic here
  },
  onSubscriptionActive: async (payload) => {
    console.log("Subscription activated:", payload);
    // Your business logic here
  },
});

Bun.serve({
  port: 3000,
  fetch(request) {
    const url = new URL(request.url);
    
    // Checkout routes
    if (url.pathname === "/api/checkout") {
      if (request.method === "GET") {
        return staticCheckoutHandler(request);
      }
      if (request.method === "POST") {
        return sessionCheckoutHandler(request);
      }
    }
    
    // Customer portal route
    if (url.pathname === "/api/customer-portal" && request.method === "GET") {
      return customerPortalHandler(request);
    }
    
    // Webhook route
    if (url.pathname === "/api/webhook/dodo-payments" && request.method === "POST") {
      return webhookHandler(request);
    }
    
    return new Response("Not Found", { status: 404 });
  },
});

console.log("Server running on http://localhost:3000");

Additional Guidance:
• Explain that the handlers are Bun-native and work seamlessly with Bun.serve()
• Highlight the use of Web Standard Request and Response objects
• Mention that error handling is built-in and returns appropriate HTTP status codes
• Provide links to the Dodo Payments documentation for more details