How to Integrate Bolt.new with SharpSpring

1// lib/sharpspring.ts
2export interface SharpSpringLead {
3  leadID?: string;
4  firstName: string;
5  lastName: string;
6  emailAddress: string;
7  companyName?: string;
8  phoneNumber?: string;
9  leadStatus?: string;
10  ownerID?: string;
11  description?: string;
12  [key: string]: string | undefined;
13}
14
15interface ApiResponse<T> {
16  result: { [key: string]: T[] } | null;
17  error: { code: number; message: string } | null;
18  id: string;
19}
20
21async function apiRequest<T>(method: string, params: Record<string, unknown>): Promise<T[]> {
22  const accountID = process.env.SHARPSPRING_ACCOUNT_ID;
23  const secretKey = process.env.SHARPSPRING_SECRET_KEY;
24
25  if (!accountID || !secretKey) {
26    throw new Error('SharpSpring credentials not configured');
27  }
28
29  const url = `https://api.sharpspring.com/pubapi/v1/?accountID=${accountID}&secretKey=${secretKey}`;
30  const requestId = `bolt-${Date.now()}`;
31
32  const response = await fetch(url, {
33    method: 'POST',
34    headers: { 'Content-Type': 'application/json' },
35    body: JSON.stringify({ method, params, id: requestId }),
36  });
37
38  if (!response.ok) {
39    throw new Error(`SharpSpring HTTP error: ${response.status}`);
40  }
41
42  const data: ApiResponse<T> = await response.json();
43
44  if (data.error) {
45    throw new Error(`SharpSpring API error ${data.error.code}: ${data.error.message}`);
46  }
47
48  if (!data.result) {
49    return [];
50  }
51
52  // SharpSpring wraps results in a key matching the data type (e.g., result.leads)
53  const resultKey = Object.keys(data.result)[0];
54  return (data.result[resultKey] as T[]) || [];
55}
56
57export async function createLeads(leads: Partial<SharpSpringLead>[]): Promise<SharpSpringLead[]> {
58  return apiRequest<SharpSpringLead>('createLeads', { objects: leads });
59}
60
61export async function getLeads(
62  where?: Record<string, string>,
63  limit = 100
64): Promise<SharpSpringLead[]> {
65  const params: Record<string, unknown> = { limit, offset: 0 };
66  if (where) params.where = where;
67  return apiRequest<SharpSpringLead>('getLeads', params);
68}
69
70export async function updateLeads(leads: Array<{ leadID: string } & Partial<SharpSpringLead>>): Promise<SharpSpringLead[]> {
71  return apiRequest<SharpSpringLead>('updateLeads', { objects: leads });
72}
73
74export async function getLeadByEmail(email: string): Promise<SharpSpringLead | null> {
75  const leads = await getLeads({ emailAddress: email }, 1);
76  return leads[0] || null;
77}

1// app/api/sharpspring/leads/route.ts
2import { NextRequest, NextResponse } from 'next/server';
3import { createLeads, updateLeads, getLeadByEmail } from '@/lib/sharpspring';
4
5const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
6
7export async function POST(request: NextRequest) {
8  const body = await request.json();
9  const { firstName, lastName, email, company, phone, message, source } = body;
10
11  // Validation
12  if (!firstName?.trim()) {
13    return NextResponse.json({ error: 'First name is required' }, { status: 400 });
14  }
15  if (!lastName?.trim()) {
16    return NextResponse.json({ error: 'Last name is required' }, { status: 400 });
17  }
18  if (!email || !emailRegex.test(email)) {
19    return NextResponse.json({ error: 'Valid email is required' }, { status: 400 });
20  }
21
22  try {
23    const existingLead = await getLeadByEmail(email);
24
25    const leadData: Record<string, string> = {
26      firstName: firstName.trim(),
27      lastName: lastName.trim(),
28      emailAddress: email.toLowerCase().trim(),
29    };
30
31    if (company) leadData.companyName = company.trim();
32    if (phone) leadData.phoneNumber = phone.trim();
33    if (message) leadData.description = message.trim();
34
35    // Add source tracking if custom field is configured
36    const sourceField = process.env.SHARPSPRING_SOURCE_FIELD;
37    if (source && sourceField) {
38      leadData[sourceField] = source;
39    }
40
41    if (existingLead?.leadID) {
42      await updateLeads([{ leadID: existingLead.leadID, ...leadData }]);
43      return NextResponse.json({ success: true, action: 'updated', leadID: existingLead.leadID });
44    } else {
45      leadData.leadStatus = 'Open - Not Contacted';
46      const created = await createLeads([leadData]);
47      const newLeadId = (created[0] as Record<string, string>)?.id;
48      return NextResponse.json({ success: true, action: 'created', leadID: newLeadId }, { status: 201 });
49    }
50  } catch (error) {
51    console.error('SharpSpring lead capture error:', error);
52    return NextResponse.json(
53      { error: 'Failed to save lead information' },
54      { status: 500 }
55    );
56  }
57}

1// app/api/sharpspring/pipeline/route.ts
2import { NextRequest, NextResponse } from 'next/server';
3import { getLeads } from '@/lib/sharpspring';
4import { createClient } from '@supabase/supabase-js';
5
6const CACHE_TTL_MINUTES = 30;
7
8interface PipelineData {
9  stages: Array<{ name: string; count: number }>;
10  byOwner: Array<{ ownerID: string; count: number }>;
11  totalLeads: number;
12  syncedAt: string;
13}
14
15async function fetchFromSharpSpring(): Promise<PipelineData> {
16  const leads = await getLeads(undefined, 500);
17
18  const stageCounts = new Map<string, number>();
19  const ownerCounts = new Map<string, number>();
20
21  for (const lead of leads) {
22    const stage = lead.leadStatus || 'Unknown';
23    stageCounts.set(stage, (stageCounts.get(stage) || 0) + 1);
24
25    if (lead.ownerID) {
26      ownerCounts.set(lead.ownerID, (ownerCounts.get(lead.ownerID) || 0) + 1);
27    }
28  }
29
30  return {
31    stages: Array.from(stageCounts.entries()).map(([name, count]) => ({ name, count })),
32    byOwner: Array.from(ownerCounts.entries()).map(([ownerID, count]) => ({ ownerID, count })),
33    totalLeads: leads.length,
34    syncedAt: new Date().toISOString(),
35  };
36}
37
38export async function GET(request: NextRequest) {
39  const { searchParams } = new URL(request.url);
40  const forceRefresh = searchParams.get('refresh') === 'true';
41
42  const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL;
43  const serviceKey = process.env.SUPABASE_SERVICE_ROLE_KEY;
44  const supabase = supabaseUrl && serviceKey ? createClient(supabaseUrl, serviceKey) : null;
45
46  // Try cache first
47  if (supabase && !forceRefresh) {
48    const { data: cached } = await supabase
49      .from('sharpspring_pipeline_cache')
50      .select('data, synced_at')
51      .order('synced_at', { ascending: false })
52      .limit(1)
53      .single();
54
55    if (cached) {
56      const ageMinutes = (Date.now() - new Date(cached.synced_at).getTime()) / 60000;
57      if (ageMinutes < CACHE_TTL_MINUTES) {
58        return NextResponse.json({ ...cached.data, fromCache: true });
59      }
60    }
61  }
62
63  try {
64    const data = await fetchFromSharpSpring();
65
66    if (supabase) {
67      await supabase.from('sharpspring_pipeline_cache').insert({ data, synced_at: data.syncedAt });
68    }
69
70    return NextResponse.json(data);
71  } catch (error) {
72    return NextResponse.json(
73      { error: (error as Error).message },
74      { status: 500 }
75    );
76  }
77}

1// app/api/sharpspring/webhook/route.ts
2// NOTE: SharpSpring webhooks require a public URL.
3// This endpoint cannot receive events in Bolt's WebContainer preview.
4// Deploy to Netlify first, then register your URL in SharpSpring Settings → API Settings → Webhooks.
5import { NextRequest, NextResponse } from 'next/server';
6
7interface SharpSpringWebhookPayload {
8  event: string;
9  lead?: {
10    leadID: string;
11    emailAddress: string;
12    leadStatus: string;
13    firstName: string;
14    lastName: string;
15  };
16}
17
18export async function POST(request: NextRequest) {
19  let payload: SharpSpringWebhookPayload;
20
21  try {
22    payload = await request.json();
23  } catch {
24    return NextResponse.json({ error: 'Invalid JSON' }, { status: 400 });
25  }
26
27  const { event, lead } = payload;
28
29  console.log(`SharpSpring webhook: ${event}`, {
30    leadID: lead?.leadID,
31    email: lead?.emailAddress,
32    status: lead?.leadStatus,
33  });
34
35  switch (event) {
36    case 'lead.status_changed':
37      // TODO: Sync updated status to your Supabase database
38      console.log(`Lead ${lead?.emailAddress} status changed to: ${lead?.leadStatus}`);
39      break;
40
41    case 'lead.created':
42      console.log(`New SharpSpring lead: ${lead?.firstName} ${lead?.lastName} <${lead?.emailAddress}>`);
43      break;
44
45    case 'lead.score_changed':
46      console.log(`Lead score changed for: ${lead?.emailAddress}`);
47      break;
48
49    default:
50      console.log(`Unhandled SharpSpring event: ${event}`);
51  }
52
53  // Always return 200 — SharpSpring retries on non-200
54  return NextResponse.json({ received: true });
55}