How to Integrate Bolt.new with Airtable

1// lib/airtable.ts
2const AIRTABLE_BASE_URL = 'https://api.airtable.com/v0';
3
4export interface AirtableRecord<T extends Record<string, unknown> = Record<string, unknown>> {
5  id: string;
6  createdTime: string;
7  fields: T;
8}
9
10interface AirtableResponse<T> {
11  records: AirtableRecord<T>[];
12  offset?: string;
13}
14
15interface AirtableFetchOptions {
16  filterByFormula?: string;
17  sort?: Array<{ field: string; direction?: 'asc' | 'desc' }>;
18  fields?: string[];
19  maxRecords?: number;
20  view?: string;
21}
22
23export async function airtableFetch<T extends Record<string, unknown> = Record<string, unknown>>(
24  tableName: string,
25  options: AirtableFetchOptions = {}
26): Promise<AirtableRecord<T>[]> {
27  const apiKey = process.env.AIRTABLE_API_KEY;
28  const baseId = process.env.AIRTABLE_BASE_ID;
29
30  if (!apiKey || !baseId) {
31    throw new Error('AIRTABLE_API_KEY and AIRTABLE_BASE_ID must be configured in .env');
32  }
33
34  const allRecords: AirtableRecord<T>[] = [];
35  let offset: string | undefined;
36
37  do {
38    const params = new URLSearchParams();
39    if (options.filterByFormula) params.set('filterByFormula', options.filterByFormula);
40    if (options.view) params.set('view', options.view);
41    if (options.maxRecords) params.set('maxRecords', String(options.maxRecords));
42    if (offset) params.set('offset', offset);
43    options.fields?.forEach((f) => params.append('fields[]', f));
44    options.sort?.forEach((s, i) => {
45      params.set(`sort[${i}][field]`, s.field);
46      params.set(`sort[${i}][direction]`, s.direction || 'asc');
47    });
48
49    const url = `${AIRTABLE_BASE_URL}/${baseId}/${encodeURIComponent(tableName)}?${params}`;
50    const response = await fetch(url, {
51      headers: { Authorization: `Bearer ${apiKey}` },
52    });
53
54    if (!response.ok) {
55      const error = await response.json().catch(() => ({})) as { error?: { message: string } };
56      throw new Error(error?.error?.message || `Airtable API error: ${response.status}`);
57    }
58
59    const data = await response.json() as AirtableResponse<T>;
60    allRecords.push(...data.records);
61    offset = data.offset;
62
63    // Respect rate limit: 5 requests/second
64    if (offset) await new Promise((r) => setTimeout(r, 250));
65  } while (offset && (!options.maxRecords || allRecords.length < options.maxRecords));
66
67  return allRecords;
68}
69
70export async function airtableCreate<T extends Record<string, unknown>>(
71  tableName: string,
72  fields: Partial<T>
73): Promise<AirtableRecord<T>> {
74  const apiKey = process.env.AIRTABLE_API_KEY;
75  const baseId = process.env.AIRTABLE_BASE_ID;
76
77  const response = await fetch(
78    `${AIRTABLE_BASE_URL}/${baseId}/${encodeURIComponent(tableName)}`,
79    {
80      method: 'POST',
81      headers: {
82        Authorization: `Bearer ${apiKey}`,
83        'Content-Type': 'application/json',
84      },
85      body: JSON.stringify({ fields }),
86    }
87  );
88
89  if (!response.ok) {
90    const error = await response.json().catch(() => ({})) as { error?: { message: string } };
91    throw new Error(error?.error?.message || `Airtable create error: ${response.status}`);
92  }
93
94  return response.json() as Promise<AirtableRecord<T>>;
95}
96
97export async function airtableUpdate<T extends Record<string, unknown>>(
98  tableName: string,
99  recordId: string,
100  fields: Partial<T>
101): Promise<AirtableRecord<T>> {
102  const apiKey = process.env.AIRTABLE_API_KEY;
103  const baseId = process.env.AIRTABLE_BASE_ID;
104
105  const response = await fetch(
106    `${AIRTABLE_BASE_URL}/${baseId}/${encodeURIComponent(tableName)}/${recordId}`,
107    {
108      method: 'PATCH',
109      headers: {
110        Authorization: `Bearer ${apiKey}`,
111        'Content-Type': 'application/json',
112      },
113      body: JSON.stringify({ fields }),
114    }
115  );
116
117  if (!response.ok) {
118    const error = await response.json().catch(() => ({})) as { error?: { message: string } };
119    throw new Error(error?.error?.message || `Airtable update error: ${response.status}`);
120  }
121
122  return response.json() as Promise<AirtableRecord<T>>;
123}

1// app/api/airtable/records/route.ts
2import { NextResponse } from 'next/server';
3import { airtableFetch } from '@/lib/airtable';
4
5// Simple in-memory cache
6const cache = new Map<string, { data: unknown; expiresAt: number }>();
7const CACHE_TTL = 60_000; // 60 seconds
8
9export async function GET(request: Request) {
10  const { searchParams } = new URL(request.url);
11  const table = searchParams.get('table');
12  const filter = searchParams.get('filter');
13  const search = searchParams.get('search');
14  const sortField = searchParams.get('sortField') || 'Name';
15  const sortDirection = (searchParams.get('sortDirection') || 'asc') as 'asc' | 'desc';
16
17  if (!table) {
18    return NextResponse.json({ error: 'table query parameter is required' }, { status: 400 });
19  }
20
21  // Build filter formula
22  let filterByFormula = filter || '';
23  if (search) {
24    const searchFormula = `SEARCH(LOWER("${search}"), LOWER({Name}))`;
25    filterByFormula = filterByFormula
26      ? `AND(${filterByFormula}, ${searchFormula})`
27      : searchFormula;
28  }
29
30  const cacheKey = `${table}|${filterByFormula}|${sortField}|${sortDirection}`;
31  const cached = cache.get(cacheKey);
32  if (cached && Date.now() < cached.expiresAt) {
33    return NextResponse.json(cached.data);
34  }
35
36  try {
37    const records = await airtableFetch(table, {
38      filterByFormula: filterByFormula || undefined,
39      sort: [{ field: sortField, direction: sortDirection }],
40      maxRecords: 500,
41    });
42
43    const result = { records, total: records.length };
44    cache.set(cacheKey, { data: result, expiresAt: Date.now() + CACHE_TTL });
45
46    return NextResponse.json(result);
47  } catch (err) {
48    const message = err instanceof Error ? err.message : 'Failed to fetch records';
49    return NextResponse.json({ error: message }, { status: 500 });
50  }
51}

1// app/api/airtable/records/create/route.ts
2import { NextResponse } from 'next/server';
3import { airtableCreate } from '@/lib/airtable';
4
5export async function POST(request: Request) {
6  const { table, fields } = await request.json() as { table: string; fields: Record<string, unknown> };
7
8  if (!table || !fields) {
9    return NextResponse.json({ error: 'table and fields are required' }, { status: 400 });
10  }
11
12  try {
13    const record = await airtableCreate(table, fields);
14    return NextResponse.json({ success: true, record });
15  } catch (err) {
16    const message = err instanceof Error ? err.message : 'Failed to create record';
17    // Check for common Airtable errors
18    const isTypeError = message.includes('INVALID_VALUE_FOR_COLUMN');
19    const isRequiredError = message.includes('CANNOT_BE_NULL');
20    return NextResponse.json(
21      {
22        error: message,
23        hint: isTypeError
24          ? 'A field value has the wrong type — check that numbers are numbers, not strings'
25          : isRequiredError
26          ? 'A required field is missing — check all required columns in your Airtable schema'
27          : undefined,
28      },
29      { status: isTypeError || isRequiredError ? 422 : 500 }
30    );
31  }
32}