How to Integrate Bolt.new with Mint

1-- supabase/migrations/001_finance_app.sql
2CREATE TABLE accounts (
3  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
4  user_id UUID REFERENCES auth.users(id) ON DELETE CASCADE NOT NULL,
5  name TEXT NOT NULL,
6  type TEXT CHECK (type IN ('checking', 'savings', 'investment', 'credit', 'loan', 'other')) NOT NULL,
7  institution TEXT,
8  is_manual BOOLEAN DEFAULT true,
9  plaid_account_id TEXT,
10  created_at TIMESTAMPTZ DEFAULT now()
11);
12
13CREATE TABLE transactions (
14  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
15  user_id UUID REFERENCES auth.users(id) ON DELETE CASCADE NOT NULL,
16  account_id UUID REFERENCES accounts(id) ON DELETE CASCADE,
17  amount DECIMAL(12, 2) NOT NULL,
18  type TEXT CHECK (type IN ('income', 'expense', 'transfer')) NOT NULL,
19  category TEXT NOT NULL,
20  description TEXT,
21  date DATE NOT NULL,
22  is_plaid BOOLEAN DEFAULT false,
23  plaid_transaction_id TEXT,
24  created_at TIMESTAMPTZ DEFAULT now()
25);
26
27CREATE TABLE budget_limits (
28  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
29  user_id UUID REFERENCES auth.users(id) ON DELETE CASCADE NOT NULL,
30  category TEXT NOT NULL,
31  monthly_limit DECIMAL(12, 2) NOT NULL,
32  UNIQUE(user_id, category)
33);
34
35-- RLS policies
36ALTER TABLE accounts ENABLE ROW LEVEL SECURITY;
37ALTER TABLE transactions ENABLE ROW LEVEL SECURITY;
38ALTER TABLE budget_limits ENABLE ROW LEVEL SECURITY;
39
40CREATE POLICY "Own accounts" ON accounts USING (user_id = auth.uid()) WITH CHECK (user_id = auth.uid());
41CREATE POLICY "Own transactions" ON transactions USING (user_id = auth.uid()) WITH CHECK (user_id = auth.uid());
42CREATE POLICY "Own budget_limits" ON budget_limits USING (user_id = auth.uid()) WITH CHECK (user_id = auth.uid());

1// app/api/plaid/link-token/route.ts
2import { NextResponse } from 'next/server';
3import { createClient } from '@/lib/supabase/server';
4
5const PLAID_BASE = `https://${process.env.PLAID_ENV ?? 'sandbox'}.plaid.com`;
6
7interface PlaidLinkTokenRequest {
8  client_id: string;
9  secret: string;
10  client_name: string;
11  user: { client_user_id: string };
12  products: string[];
13  country_codes: string[];
14  language: string;
15}
16
17export async function POST() {
18  const supabase = await createClient();
19  const { data: { user } } = await supabase.auth.getUser();
20
21  if (!user) {
22    return NextResponse.json({ error: 'Not authenticated' }, { status: 401 });
23  }
24
25  const requestBody: PlaidLinkTokenRequest = {
26    client_id: process.env.PLAID_CLIENT_ID ?? '',
27    secret: process.env.PLAID_SECRET ?? '',
28    client_name: 'My Finance App',
29    user: { client_user_id: user.id },
30    products: ['transactions'],
31    country_codes: ['US'],
32    language: 'en',
33  };
34
35  try {
36    const response = await fetch(`${PLAID_BASE}/link/token/create`, {
37      method: 'POST',
38      headers: { 'Content-Type': 'application/json' },
39      body: JSON.stringify(requestBody),
40    });
41
42    if (!response.ok) {
43      const error = await response.json();
44      return NextResponse.json(
45        { error: error.error_message ?? 'Failed to create link token' },
46        { status: response.status }
47      );
48    }
49
50    const data = await response.json();
51    return NextResponse.json({ link_token: data.link_token });
52  } catch (error) {
53    const message = error instanceof Error ? error.message : 'Request failed';
54    return NextResponse.json({ error: message }, { status: 500 });
55  }
56}

1// app/api/plaid/transactions/route.ts
2import { NextRequest, NextResponse } from 'next/server';
3
4const PLAID_BASE = `https://${process.env.PLAID_ENV ?? 'sandbox'}.plaid.com`;
5
6// Map Plaid primary categories to simplified app categories
7const CATEGORY_MAP: Record<string, string> = {
8  'Food and Drink': 'Food',
9  'Shops': 'Shopping',
10  'Travel': 'Transport',
11  'Recreation': 'Entertainment',
12  'Healthcare': 'Healthcare',
13  'Service': 'Services',
14  'Transfer': 'Transfer',
15  'Payment': 'Bills',
16  'Bank Fees': 'Bills',
17  'Community': 'Other',
18  'Income': 'Income',
19  'Tax': 'Bills',
20  'Cash Advance': 'Other',
21};
22
23export async function GET(request: NextRequest) {
24  // In production: get access_token from database for current user
25  // For development: use env var as a shortcut
26  const accessToken = process.env.PLAID_ACCESS_TOKEN;
27
28  if (!accessToken) {
29    return NextResponse.json(
30      { error: 'No Plaid access token configured. Connect a bank account first.' },
31      { status: 400 }
32    );
33  }
34
35  const endDate = new Date().toISOString().split('T')[0];
36  const startDate = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString().split('T')[0];
37
38  try {
39    const response = await fetch(`${PLAID_BASE}/transactions/get`, {
40      method: 'POST',
41      headers: { 'Content-Type': 'application/json' },
42      body: JSON.stringify({
43        client_id: process.env.PLAID_CLIENT_ID,
44        secret: process.env.PLAID_SECRET,
45        access_token: accessToken,
46        start_date: startDate,
47        end_date: endDate,
48        options: { count: 50, offset: 0 },
49      }),
50    });
51
52    if (!response.ok) {
53      const err = await response.json();
54      return NextResponse.json({ error: err.error_message }, { status: response.status });
55    }
56
57    const data = await response.json();
58
59    const transactions = data.transactions.map((t: {
60      transaction_id: string;
61      name: string;
62      amount: number;
63      date: string;
64      category?: string[];
65      pending: boolean;
66      account_id: string;
67    }) => ({
68      id: t.transaction_id,
69      description: t.name,
70      // Plaid: positive = debit (expense), negative = credit (income)
71      amount: Math.abs(t.amount),
72      type: t.amount > 0 ? 'expense' : 'income',
73      category: CATEGORY_MAP[t.category?.[0] ?? ''] ?? 'Other',
74      date: t.date,
75      pending: t.pending,
76      accountId: t.account_id,
77    }));
78
79    return NextResponse.json({ transactions, total: data.total_transactions });
80  } catch (error) {
81    const message = error instanceof Error ? error.message : 'Request failed';
82    return NextResponse.json({ error: message }, { status: 500 });
83  }
84}

1// app/budget/actions.ts
2'use server';
3import { createClient } from '@/lib/supabase/server';
4import { revalidatePath } from 'next/cache';
5import { z } from 'zod';
6
7const TransactionSchema = z.object({
8  amount: z.number().positive('Amount must be greater than 0'),
9  type: z.enum(['income', 'expense']),
10  category: z.string().min(1, 'Category is required'),
11  description: z.string().optional(),
12  date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, 'Invalid date format'),
13});
14
15export async function addTransaction(input: z.infer<typeof TransactionSchema>) {
16  const supabase = await createClient();
17  const { data: { user } } = await supabase.auth.getUser();
18  if (!user) return { error: 'Not authenticated' };
19
20  const parsed = TransactionSchema.safeParse(input);
21  if (!parsed.success) {
22    return { error: parsed.error.errors[0].message };
23  }
24
25  const { error } = await supabase.from('transactions').insert({
26    user_id: user.id,
27    amount: parsed.data.amount,
28    type: parsed.data.type,
29    category: parsed.data.category,
30    description: parsed.data.description ?? null,
31    date: parsed.data.date,
32    is_plaid: false,
33  });
34
35  if (error) return { error: error.message };
36
37  revalidatePath('/budget');
38  return { success: true };
39}
40
41export async function getMonthlySummary(userId: string, year: number, month: number) {
42  const supabase = await createClient();
43  const startDate = `${year}-${String(month).padStart(2, '0')}-01`;
44  const endDate = new Date(year, month, 0).toISOString().split('T')[0];
45
46  const { data } = await supabase
47    .from('transactions')
48    .select('amount, type, category')
49    .eq('user_id', userId)
50    .gte('date', startDate)
51    .lte('date', endDate);
52
53  const income = data?.filter((t) => t.type === 'income').reduce((sum, t) => sum + Number(t.amount), 0) ?? 0;
54  const expenses = data?.filter((t) => t.type === 'expense').reduce((sum, t) => sum + Number(t.amount), 0) ?? 0;
55
56  const byCategory = data?.reduce((acc: Record<string, number>, t) => {
57    if (t.type === 'expense') {
58      acc[t.category] = (acc[t.category] ?? 0) + Number(t.amount);
59    }
60    return acc;
61  }, {}) ?? {};
62
63  return { income, expenses, net: income - expenses, byCategory };
64}