How to Integrate Bolt.new with Drip

1// lib/drip.ts
2const API_BASE = 'https://api.getdrip.com/v2';
3
4interface DripApiOptions {
5  method?: 'GET' | 'POST' | 'PUT' | 'DELETE';
6  body?: unknown;
7}
8
9async function dripRequest<T>(path: string, options: DripApiOptions = {}): Promise<T> {
10  const token = process.env.DRIP_API_TOKEN;
11  const accountId = process.env.DRIP_ACCOUNT_ID;
12  if (!token || !accountId) throw new Error('DRIP_API_TOKEN and DRIP_ACCOUNT_ID must be set');
13
14  const url = `${API_BASE}/${accountId}${path}`;
15  const response = await fetch(url, {
16    method: options.method || 'GET',
17    headers: {
18      'Authorization': `Bearer ${token}`,
19      'Content-Type': 'application/json',
20      'User-Agent': 'Bolt.new Integration/1.0',
21    },
22    ...(options.body ? { body: JSON.stringify(options.body) } : {}),
23  });
24
25  if (response.status === 204) return null as T;
26  const data = await response.json();
27  if (!response.ok) throw new Error(data.errors?.[0]?.message || `Drip API error: ${response.status}`);
28  return data as T;
29}
30
31export async function upsertSubscriber(
32  email: string,
33  data: {
34    firstName?: string;
35    lastName?: string;
36    customFields?: Record<string, string>;
37    tags?: string[];
38  } = {}
39): Promise<void> {
40  await dripRequest('/subscribers', {
41    method: 'POST',
42    body: {
43      subscribers: [{
44        email,
45        first_name: data.firstName,
46        last_name: data.lastName,
47        custom_fields: data.customFields,
48        tags: data.tags,
49        new_email: undefined,
50      }],
51    },
52  });
53}
54
55export async function applyTag(email: string, tag: string): Promise<void> {
56  await dripRequest('/tags', {
57    method: 'POST',
58    body: { tags: [{ email, tag }] },
59  });
60}
61
62export async function removeTag(email: string, tag: string): Promise<void> {
63  await dripRequest(`/subscribers/${encodeURIComponent(email)}/remove_tag`, {
64    method: 'POST',
65    body: { tag },
66  });
67}
68
69export async function trackEvent(
70  email: string,
71  action: string,
72  properties: Record<string, unknown> = {},
73  occurredAt?: string
74): Promise<void> {
75  await dripRequest('/events', {
76    method: 'POST',
77    body: {
78      events: [{
79        email,
80        action,
81        properties,
82        occurred_at: occurredAt || new Date().toISOString(),
83      }],
84    },
85  });
86}
87
88export async function getSubscriber(email: string) {
89  const data = await dripRequest<{ subscribers: Array<Record<string, unknown>> }>(
90    `/subscribers/${encodeURIComponent(email)}`
91  );
92  return data?.subscribers?.[0] || null;
93}

1// lib/drip-ecommerce.ts
2import { trackEvent } from './drip';
3
4interface CartItem {
5  productId: string;
6  productName: string;
7  price: number;
8  quantity: number;
9}
10
11export async function trackProductView(
12  email: string,
13  productId: string,
14  productName: string,
15  price: number,
16  url: string
17): Promise<void> {
18  await trackEvent(email, 'Viewed a Product', {
19    product_id: productId,
20    product_name: productName,
21    price,
22    product_url: url,
23  });
24}
25
26export async function trackCartAdd(
27  email: string,
28  cartId: string,
29  productName: string,
30  price: number,
31  quantity: number,
32  cartTotal: number
33): Promise<void> {
34  await trackEvent(email, 'Added a Product to the Cart', {
35    cart_id: cartId,
36    product_name: productName,
37    price,
38    quantity,
39    cart_total: cartTotal,
40  });
41}
42
43export async function trackCartAbandonment(
44  email: string,
45  cartId: string,
46  items: CartItem[],
47  total: number
48): Promise<void> {
49  await trackEvent(email, 'Abandoned a Cart', {
50    cart_id: cartId,
51    total,
52    item_count: items.reduce((sum, item) => sum + item.quantity, 0),
53    items: items.map((item) => ({
54      product_id: item.productId,
55      product_name: item.productName,
56      price: item.price,
57      quantity: item.quantity,
58    })),
59  });
60}
61
62export async function trackPurchase(
63  email: string,
64  orderId: string,
65  total: number, // in dollars, not cents
66  currency: string,
67  items: CartItem[]
68): Promise<void> {
69  await trackEvent(email, 'Placed Order', {
70    order_id: orderId,
71    grand_total: total,
72    currency,
73    item_count: items.reduce((sum, item) => sum + item.quantity, 0),
74    items: items.map((item) => ({
75      product_id: item.productId,
76      product_name: item.productName,
77      price: item.price,
78      quantity: item.quantity,
79    })),
80  });
81}

1// Integration example: adding Drip to an existing Stripe webhook handler
2// In your existing app/api/stripe/webhook/route.ts:
3import { trackPurchase } from '@/lib/drip-ecommerce';
4import { upsertSubscriber, applyTag } from '@/lib/drip';
5
6// Inside your checkout.session.completed handler:
7async function handleCheckoutCompleted(session: Stripe.Checkout.Session) {
8  const email = session.customer_details?.email || session.customer_email;
9  if (!email) return;
10
11  // Your existing logic: update database, fulfill order, etc.
12  // ...
13
14  // Track purchase in Drip (non-blocking — errors do not affect Stripe processing)
15  try {
16    await trackPurchase(
17      email,
18      session.payment_intent as string || session.id,
19      (session.amount_total || 0) / 100, // Convert cents to dollars
20      session.currency || 'usd',
21      [] // Map line items from session.line_items if available
22    );
23    await applyTag(email, 'customer');
24  } catch (dripError) {
25    console.error('Drip tracking failed (non-critical):', dripError);
26    // Do not rethrow — Stripe webhook must return 200
27  }
28}
29
30// Integration example: adding Drip to user signup
31async function onUserSignup(
32  email: string,
33  firstName: string,
34  lastName: string,
35  plan: 'free' | 'pro' | 'enterprise'
36) {
37  // Your existing logic: create Supabase user, etc.
38  // ...
39
40  // Subscribe to Drip (non-blocking)
41  try {
42    await upsertSubscriber(email, {
43      firstName,
44      lastName,
45      tags: [plan === 'free' ? 'free-trial' : 'customer'],
46      customFields: { plan_tier: plan, signup_date: new Date().toISOString() },
47    });
48  } catch (dripError) {
49    console.error('Drip subscribe failed (non-critical):', dripError);
50  }
51}

1// app/api/drip/webhook/route.ts
2// NOTE: Drip webhooks require a publicly accessible URL.
3// This route cannot receive events in Bolt's WebContainer preview.
4// Deploy to Netlify first, then register your URL in Drip Settings → Webhooks.
5import { NextRequest, NextResponse } from 'next/server';
6
7interface DripWebhookPayload {
8  event: string;
9  data: {
10    account_id: string;
11    subscriber?: {
12      email: string;
13      id: string;
14      first_name: string;
15      last_name: string;
16      tags: string[];
17      custom_fields: Record<string, string>;
18    };
19    workflow?: { name: string; id: string };
20    occurred_at: string;
21  };
22}
23
24export async function POST(request: NextRequest) {
25  let payload: DripWebhookPayload;
26  try {
27    payload = await request.json();
28  } catch {
29    return NextResponse.json({ error: 'Invalid JSON' }, { status: 400 });
30  }
31
32  const { event, data } = payload;
33  const email = data.subscriber?.email;
34
35  switch (event) {
36    case 'subscriber.created':
37      console.log(`Drip: New subscriber — ${email}`);
38      break;
39
40    case 'subscriber.subscribed_to_workflow':
41      console.log(`Drip: ${email} entered workflow '${data.workflow?.name}'`);
42      break;
43
44    case 'subscriber.performed_custom_event':
45      console.log(`Drip: Custom event for ${email}`);
46      break;
47
48    case 'subscriber.unsubscribed':
49      console.log(`Drip: Unsubscribe — ${email}`);
50      // TODO: Update subscriber status in Supabase
51      break;
52
53    default:
54      console.log(`Drip unhandled webhook event: ${event}`);
55  }
56
57  return NextResponse.json({ received: true });
58}