How to Integrate Bolt.new with Zoho Books

1// .env.local
2ZOHO_CLIENT_ID=your_zoho_client_id
3ZOHO_CLIENT_SECRET=your_zoho_client_secret
4ZOHO_REDIRECT_URI=https://your-app.netlify.app/api/zoho/callback
5ZOHO_REGION=com  # com, eu, in, com.au, jp
6ZOHO_BOOKS_ORG_ID=your_organization_id  # Set after first OAuth
7
8// lib/zoho-auth.ts
9export function getZohoRegion(): string {
10  return process.env.ZOHO_REGION ?? 'com';
11}
12
13export function getZohoAuthBaseUrl(): string {
14  return `https://accounts.zoho.${getZohoRegion()}`;
15}
16
17export function getZohoBooksBaseUrl(): string {
18  return `https://books.zoho.${getZohoRegion()}/api/v3`;
19}
20
21export function buildAuthUrl(state: string): string {
22  const baseUrl = getZohoAuthBaseUrl();
23  const params = new URLSearchParams({
24    response_type: 'code',
25    client_id: process.env.ZOHO_CLIENT_ID!,
26    scope: [
27      'ZohoBooks.invoices.READ',
28      'ZohoBooks.invoices.CREATE',
29      'ZohoBooks.contacts.READ',
30      'ZohoBooks.contacts.CREATE',
31      'ZohoBooks.expenses.READ',
32      'ZohoBooks.expenses.CREATE',
33    ].join(','),
34    redirect_uri: process.env.ZOHO_REDIRECT_URI!,
35    access_type: 'offline',
36    state,
37  });
38  return `${baseUrl}/oauth/v2/auth?${params.toString()}`;
39}
40
41// app/api/zoho/authorize/route.ts
42import { NextResponse } from 'next/server';
43import { buildAuthUrl } from '@/lib/zoho-auth';
44
45export async function GET() {
46  const state = Math.random().toString(36).substring(2, 15);
47  const authUrl = buildAuthUrl(state);
48  const response = NextResponse.redirect(authUrl);
49  response.cookies.set('zoho_oauth_state', state, { httpOnly: true, maxAge: 600 });
50  return response;
51}

1// app/api/zoho/callback/route.ts
2import { NextRequest, NextResponse } from 'next/server';
3import { getZohoAuthBaseUrl, getZohoBooksBaseUrl } from '@/lib/zoho-auth';
4
5export async function GET(request: NextRequest) {
6  const { searchParams } = new URL(request.url);
7  const code = searchParams.get('code');
8  const error = searchParams.get('error');
9
10  if (error || !code) {
11    return NextResponse.redirect(new URL(`/error?message=${error ?? 'no_code'}`, request.url));
12  }
13
14  try {
15    // Exchange code for tokens
16    const tokenResponse = await fetch(`${getZohoAuthBaseUrl()}/oauth/v2/token`, {
17      method: 'POST',
18      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
19      body: new URLSearchParams({
20        code,
21        client_id: process.env.ZOHO_CLIENT_ID!,
22        client_secret: process.env.ZOHO_CLIENT_SECRET!,
23        redirect_uri: process.env.ZOHO_REDIRECT_URI!,
24        grant_type: 'authorization_code',
25      }).toString(),
26    });
27
28    const tokens = await tokenResponse.json() as {
29      access_token: string;
30      refresh_token: string;
31      expires_in: number;
32      token_type: string;
33    };
34
35    if (!tokens.access_token) {
36      throw new Error('No access token in response');
37    }
38
39    // Fetch organization ID
40    const orgsResponse = await fetch(`${getZohoBooksBaseUrl()}/organizations`, {
41      headers: { Authorization: `Zoho-oauthtoken ${tokens.access_token}` },
42    });
43    const orgsData = await orgsResponse.json() as { organizations: Array<{ organization_id: string; name: string }> };
44    const orgId = orgsData.organizations[0]?.organization_id;
45
46    if (!orgId) throw new Error('No Zoho Books organization found');
47
48    const response = NextResponse.redirect(new URL('/dashboard', request.url));
49    const cookieOpts = { httpOnly: true, secure: process.env.NODE_ENV === 'production', sameSite: 'lax' as const, maxAge: 60 * 60 * 24 * 30, path: '/' };
50    response.cookies.set('zoho_access_token', tokens.access_token, { ...cookieOpts, maxAge: tokens.expires_in });
51    response.cookies.set('zoho_refresh_token', tokens.refresh_token, cookieOpts);
52    response.cookies.set('zoho_token_expiry', String(Date.now() + tokens.expires_in * 1000), cookieOpts);
53    response.cookies.set('zoho_org_id', orgId, cookieOpts);
54
55    return response;
56  } catch (err) {
57    console.error('Zoho OAuth error:', err);
58    return NextResponse.redirect(new URL('/error?message=zoho_auth_failed', request.url));
59  }
60}

1// lib/zoho-api.ts
2import { cookies } from 'next/headers';
3import { getZohoAuthBaseUrl, getZohoBooksBaseUrl } from './zoho-auth';
4
5async function refreshAccessToken(refreshToken: string): Promise<{ access_token: string; expires_in: number }> {
6  const response = await fetch(`${getZohoAuthBaseUrl()}/oauth/v2/token`, {
7    method: 'POST',
8    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
9    body: new URLSearchParams({
10      refresh_token: refreshToken,
11      client_id: process.env.ZOHO_CLIENT_ID!,
12      client_secret: process.env.ZOHO_CLIENT_SECRET!,
13      grant_type: 'refresh_token',
14    }).toString(),
15  });
16  return response.json();
17}
18
19export async function zohoBooksCall<T>(
20  path: string,
21  options: RequestInit = {}
22): Promise<T> {
23  const cookieStore = cookies();
24  let accessToken = cookieStore.get('zoho_access_token')?.value;
25  const refreshToken = cookieStore.get('zoho_refresh_token')?.value;
26  const tokenExpiry = parseInt(cookieStore.get('zoho_token_expiry')?.value ?? '0', 10);
27  const orgId = cookieStore.get('zoho_org_id')?.value;
28
29  if (!accessToken || !orgId) throw new Error('Not authenticated with Zoho Books');
30
31  // Refresh if within 5 minutes of expiry
32  if (refreshToken && tokenExpiry - Date.now() < 5 * 60 * 1000) {
33    const fresh = await refreshAccessToken(refreshToken);
34    accessToken = fresh.access_token;
35  }
36
37  const url = new URL(`${getZohoBooksBaseUrl()}${path}`);
38  url.searchParams.set('organization_id', orgId);
39
40  const response = await fetch(url.toString(), {
41    ...options,
42    headers: {
43      Authorization: `Zoho-oauthtoken ${accessToken}`,
44      'Content-Type': 'application/json',
45      ...(options.headers ?? {}),
46    },
47  });
48
49  if (!response.ok) {
50    throw new Error(`Zoho Books API error: ${response.status}`);
51  }
52
53  return response.json() as Promise<T>;
54}
55
56// app/api/zoho-books/invoices/route.ts
57import { NextRequest, NextResponse } from 'next/server';
58import { zohoBooksCall } from '@/lib/zoho-api';
59
60interface ZohoInvoice {
61  invoice_id: string;
62  invoice_number: string;
63  customer_name: string;
64  date: string;
65  due_date: string;
66  total: number;
67  balance: number;
68  status: string;
69}
70
71export async function GET(request: NextRequest) {
72  const { searchParams } = new URL(request.url);
73  const status = searchParams.get('status') ?? 'sent,overdue';
74
75  try {
76    const data = await zohoBooksCall<{ invoices: ZohoInvoice[]; page_context: Record<string, unknown> }>(
77      `/invoices?status=${encodeURIComponent(status)}&sort_column=date&sort_order=D&per_page=200`
78    );
79
80    const today = new Date();
81    const invoices = data.invoices.map((inv) => {
82      const dueDate = inv.due_date ? new Date(inv.due_date) : null;
83      const daysOverdue = dueDate && dueDate < today && inv.balance > 0
84        ? Math.floor((today.getTime() - dueDate.getTime()) / (1000 * 60 * 60 * 24))
85        : 0;
86      return {
87        id: inv.invoice_id,
88        invoiceNumber: inv.invoice_number,
89        customerName: inv.customer_name,
90        date: inv.date,
91        dueDate: inv.due_date,
92        total: inv.total,
93        balance: inv.balance,
94        status: inv.status,
95        daysOverdue,
96      };
97    });
98
99    return NextResponse.json({ invoices, total: invoices.length });
100  } catch (error) {
101    const message = error instanceof Error ? error.message : 'Failed to fetch invoices';
102    return NextResponse.json({ error: message }, { status: 500 });
103  }
104}

1// app/api/zoho-books/invoices/create/route.ts
2import { NextRequest, NextResponse } from 'next/server';
3import { zohoBooksCall } from '@/lib/zoho-api';
4
5export async function POST(request: NextRequest) {
6  const body = await request.json() as {
7    customerId: string;
8    lineItems: Array<{ description: string; quantity: number; rate: number }>;
9    dueDate: string;
10    notes?: string;
11    sendEmail?: boolean;
12  };
13
14  try {
15    const invoicePayload = {
16      customer_id: body.customerId,
17      date: new Date().toISOString().split('T')[0],
18      due_date: body.dueDate,
19      notes: body.notes ?? '',
20      line_items: body.lineItems.map((item) => ({
21        description: item.description,
22        quantity: item.quantity,
23        rate: item.rate,
24      })),
25    };
26
27    const data = await zohoBooksCall<{
28      invoice: {
29        invoice_id: string;
30        invoice_number: string;
31        total: number;
32        status: string;
33      };
34    }>('/invoices', {
35      method: 'POST',
36      body: JSON.stringify(invoicePayload),
37    });
38
39    const inv = data.invoice;
40
41    // Optionally send the invoice email
42    if (body.sendEmail) {
43      await zohoBooksCall(`/invoices/${inv.invoice_id}/email`, { method: 'POST' });
44    }
45
46    return NextResponse.json({
47      invoiceId: inv.invoice_id,
48      invoiceNumber: inv.invoice_number,
49      total: inv.total,
50      status: inv.status,
51      viewUrl: `https://books.zoho.${process.env.ZOHO_REGION ?? 'com'}/app#/invoices/${inv.invoice_id}`,
52    });
53  } catch (error) {
54    const message = error instanceof Error ? error.message : 'Invoice creation failed';
55    return NextResponse.json({ error: message }, { status: 500 });
56  }
57}