How to Integrate Bolt.new with Zoho CRM

1// lib/zoho.ts
2const ZOHO_ACCOUNTS_URL = process.env.ZOHO_ACCOUNTS_URL || 'https://accounts.zoho.com';
3const ZOHO_API_URL = process.env.ZOHO_API_URL || 'https://www.zohoapis.com/crm/v6';
4
5let cachedToken: { token: string; expiresAt: number } | null = null;
6
7export async function getZohoAccessToken(): Promise<string> {
8  // Return cached token if still valid (with 5 min buffer)
9  if (cachedToken && Date.now() < cachedToken.expiresAt - 5 * 60 * 1000) {
10    return cachedToken.token;
11  }
12
13  const refreshToken = process.env.ZOHO_REFRESH_TOKEN;
14  const clientId = process.env.ZOHO_CLIENT_ID;
15  const clientSecret = process.env.ZOHO_CLIENT_SECRET;
16
17  if (!refreshToken || !clientId || !clientSecret) {
18    throw new Error('Zoho CRM credentials are not configured. Set ZOHO_CLIENT_ID, ZOHO_CLIENT_SECRET, and ZOHO_REFRESH_TOKEN.');
19  }
20
21  const response = await fetch(`${ZOHO_ACCOUNTS_URL}/oauth/v2/token`, {
22    method: 'POST',
23    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
24    body: new URLSearchParams({
25      grant_type: 'refresh_token',
26      client_id: clientId,
27      client_secret: clientSecret,
28      refresh_token: refreshToken,
29    }),
30  });
31
32  const data = await response.json() as { access_token?: string; error?: string };
33
34  if (!data.access_token) {
35    throw new Error(`Zoho token refresh failed: ${data.error || 'unknown error'}`);
36  }
37
38  cachedToken = {
39    token: data.access_token,
40    expiresAt: Date.now() + 60 * 60 * 1000, // 60 minutes
41  };
42
43  return data.access_token;
44}
45
46export async function zohoFetch<T = unknown>(
47  endpoint: string,
48  options: RequestInit = {}
49): Promise<T> {
50  const accessToken = await getZohoAccessToken();
51  const response = await fetch(`${ZOHO_API_URL}/${endpoint}`, {
52    ...options,
53    headers: {
54      Authorization: `Zoho-oauthtoken ${accessToken}`,
55      'Content-Type': 'application/json',
56      ...options.headers,
57    },
58  });
59
60  if (!response.ok) {
61    const error = await response.json().catch(() => ({})) as { message?: string };
62    throw new Error(error.message || `Zoho API error: ${response.status}`);
63  }
64
65  return response.json() as Promise<T>;
66}

1// app/api/zoho/auth/route.ts
2import { NextResponse } from 'next/server';
3
4export async function GET() {
5  const clientId = process.env.ZOHO_CLIENT_ID;
6  const redirectUri = process.env.ZOHO_REDIRECT_URI;
7  const accountsUrl = process.env.ZOHO_ACCOUNTS_URL || 'https://accounts.zoho.com';
8
9  if (!clientId || !redirectUri) {
10    return NextResponse.json({ error: 'ZOHO_CLIENT_ID and ZOHO_REDIRECT_URI must be configured' }, { status: 500 });
11  }
12
13  const params = new URLSearchParams({
14    scope: 'ZohoCRM.modules.ALL',
15    client_id: clientId,
16    response_type: 'code',
17    access_type: 'offline', // Required for refresh token
18    redirect_uri: redirectUri,
19  });
20
21  return NextResponse.redirect(`${accountsUrl}/oauth/v2/auth?${params}`);
22}
23
24// app/api/zoho/callback/route.ts
25// import { NextResponse } from 'next/server';
26// export async function GET(request: Request) {
27//   const { searchParams } = new URL(request.url);
28//   const code = searchParams.get('code');
29//   if (!code) return NextResponse.json({ error: 'No authorization code received' }, { status: 400 });
30//   const tokenResponse = await fetch(`${process.env.ZOHO_ACCOUNTS_URL}/oauth/v2/token`, {
31//     method: 'POST',
32//     headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
33//     body: new URLSearchParams({
34//       grant_type: 'authorization_code',
35//       client_id: process.env.ZOHO_CLIENT_ID!,
36//       client_secret: process.env.ZOHO_CLIENT_SECRET!,
37//       redirect_uri: process.env.ZOHO_REDIRECT_URI!,
38//       code,
39//     }),
40//   });
41//   const tokens = await tokenResponse.json();
42//   console.log('ZOHO REFRESH TOKEN (copy to .env):', tokens.refresh_token);
43//   return NextResponse.json({ message: 'Copy refresh_token from server logs', refresh_token: tokens.refresh_token });
44// }

1// app/api/zoho/deals/route.ts
2import { NextResponse } from 'next/server';
3import { zohoFetch } from '@/lib/zoho';
4
5interface ZohoDeal {
6  id: string;
7  Deal_Name: string;
8  Stage: string;
9  Amount: number | null;
10  Closing_Date: string | null;
11  Account_Name?: { name: string; id: string };
12  Owner?: { name: string; id: string };
13  Probability: number | null;
14}
15
16interface ZohoResponse<T> {
17  data: T[];
18  info: { count: number; more_records: boolean; page: number };
19}
20
21export async function GET() {
22  try {
23    const data = await zohoFetch<ZohoResponse<ZohoDeal>>(
24      'Deals?fields=Deal_Name,Stage,Amount,Closing_Date,Account_Name,Owner,Probability&sort_by=Stage&sort_order=asc&per_page=200'
25    );
26
27    const deals = data.data || [];
28
29    // Group deals by stage and calculate totals
30    const stageMap = new Map<string, { deals: ZohoDeal[]; total: number }>();
31    for (const deal of deals) {
32      const stage = deal.Stage || 'Unknown';
33      if (!stageMap.has(stage)) stageMap.set(stage, { deals: [], total: 0 });
34      const entry = stageMap.get(stage)!;
35      entry.deals.push(deal);
36      entry.total += deal.Amount || 0;
37    }
38
39    const stages = Array.from(stageMap.entries()).map(([name, { deals: stageDeals, total }]) => ({
40      name,
41      dealCount: stageDeals.length,
42      totalValue: total,
43      deals: stageDeals,
44    }));
45
46    const totalPipelineValue = deals
47      .filter((d) => !['Closed Won', 'Closed Lost'].includes(d.Stage))
48      .reduce((sum, d) => sum + (d.Amount || 0), 0);
49
50    return NextResponse.json({
51      deals,
52      stages,
53      summary: {
54        total: deals.length,
55        totalPipelineValue,
56        wonCount: deals.filter((d) => d.Stage === 'Closed Won').length,
57        lostCount: deals.filter((d) => d.Stage === 'Closed Lost').length,
58      },
59    });
60  } catch (err) {
61    const message = err instanceof Error ? err.message : 'Failed to fetch deals';
62    return NextResponse.json({ error: message }, { status: 500 });
63  }
64}

1// app/api/zoho/contacts/create/route.ts
2import { NextResponse } from 'next/server';
3import { zohoFetch } from '@/lib/zoho';
4
5interface ZohoSearchResponse {
6  data?: Array<{ id: string; Full_Name: string; Email: string }>;
7}
8
9interface ZohoCreateResponse {
10  data: Array<{
11    code: string;
12    details: { id: string };
13    message: string;
14    status: string;
15  }>;
16}
17
18export async function POST(request: Request) {
19  const { firstName, lastName, email, phone, company, leadSource } = await request.json();
20
21  if (!lastName) {
22    return NextResponse.json({ error: 'Last name is required' }, { status: 400 });
23  }
24
25  try {
26    // Check for duplicate by email
27    if (email) {
28      const existing = await zohoFetch<ZohoSearchResponse>(
29        `Contacts/search?criteria=(Email:equals:${encodeURIComponent(email)})`
30      ).catch(() => ({ data: [] }));
31
32      if (existing.data && existing.data.length > 0) {
33        return NextResponse.json({
34          duplicate: true,
35          id: existing.data[0].id,
36          name: existing.data[0].Full_Name,
37          message: 'Contact with this email already exists',
38        });
39      }
40    }
41
42    // Create new contact
43    const result = await zohoFetch<ZohoCreateResponse>('Contacts', {
44      method: 'POST',
45      body: JSON.stringify({
46        data: [
47          {
48            First_Name: firstName || '',
49            Last_Name: lastName,
50            Email: email || undefined,
51            Phone: phone || undefined,
52            Account_Name: company ? { name: company } : undefined,
53            Lead_Source: leadSource || undefined,
54          },
55        ],
56      }),
57    });
58
59    const record = result.data?.[0];
60    if (record?.status !== 'success') {
61      throw new Error(record?.message || 'Contact creation failed');
62    }
63
64    return NextResponse.json({
65      created: true,
66      id: record.details.id,
67      message: `Contact ${firstName ? firstName + ' ' : ''}${lastName} created successfully`,
68    });
69  } catch (err) {
70    const message = err instanceof Error ? err.message : 'Failed to create contact';
71    return NextResponse.json({ error: message }, { status: 500 });
72  }
73}