How to Build Resume parser with V0

1// Paste this prompt into V0's AI chat:
2// Build a resume parser. Create a Supabase schema with:
3// 1. parsed_resumes: id (uuid PK), uploader_id (uuid FK), original_file_url (text), original_filename (text), parsed_data (jsonb), confidence_score (numeric), status (text check uploading/parsing/completed/failed), error_message (text nullable), created_at (timestamptz)
4// 2. extracted_candidates: id (uuid PK), parsed_resume_id (uuid FK unique), full_name (text), email (text), phone (text), location (text), summary (text), total_experience_years (numeric), skills (text[]), created_at (timestamptz)
5// 3. extracted_experiences: id (uuid PK), candidate_id (uuid FK), company (text), title (text), start_date (text), end_date (text), description (text), position (integer)
6// 4. extracted_education: id (uuid PK), candidate_id (uuid FK), institution (text), degree (text), field (text), year (text)
7// Create a private Supabase Storage bucket 'resumes'.
8// RLS: authenticated users can CRUD their own parsed_resumes.
9// Generate SQL migration and TypeScript types.

1// Paste this prompt into V0's AI chat:
2// Build a resume upload page at app/parser/page.tsx.
3// Requirements:
4// - Drag-and-drop upload zone that accepts PDF files only (max 5MB)
5// - Visual feedback: dashed border on drag-over, file icon, "Drop your resume here" text
6// - On file drop/select:
7//   - Show filename and file size
8//   - Show Progress bar during upload
9//   - Upload to Supabase Storage 'resumes' private bucket
10//   - Create parsed_resumes record with status 'uploading'
11//   - Call /api/parser/extract to trigger AI extraction
12//   - Redirect to /parser/[id] when extraction starts
13// - Below the upload zone: Table of previously parsed resumes
14//   - Columns: filename, status Badge (uploading=gray, parsing=yellow, completed=green, failed=red), confidence score, parsed date
15//   - Each row links to /parser/[id]
16// - Use shadcn/ui Card for upload zone, Progress, Badge, Table, Skeleton
17// - 'use client' for drag-and-drop and file handling

1import { NextRequest, NextResponse } from 'next/server'
2import { createClient } from '@supabase/supabase-js'
3
4export const maxDuration = 60
5
6const supabase = createClient(
7  process.env.SUPABASE_URL!,
8  process.env.SUPABASE_SERVICE_ROLE_KEY!
9)
10
11export async function POST(req: NextRequest) {
12  const { resume_id, file_path } = await req.json()
13
14  await supabase
15    .from('parsed_resumes')
16    .update({ status: 'parsing' })
17    .eq('id', resume_id)
18
19  const { data: fileData } = await supabase.storage
20    .from('resumes')
21    .download(file_path)
22
23  if (!fileData) {
24    await supabase.from('parsed_resumes').update({
25      status: 'failed',
26      error_message: 'File not found',
27    }).eq('id', resume_id)
28    return NextResponse.json({ error: 'File not found' }, { status: 404 })
29  }
30
31  const text = await fileData.text()
32
33  const response = await fetch('https://api.openai.com/v1/chat/completions', {
34    method: 'POST',
35    headers: {
36      Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
37      'Content-Type': 'application/json',
38    },
39    body: JSON.stringify({
40      model: 'gpt-4o',
41      messages: [
42        {
43          role: 'system',
44          content: 'Extract structured resume data from the following text. Be precise with dates and job titles.',
45        },
46        { role: 'user', content: text },
47      ],
48      response_format: {
49        type: 'json_schema',
50        json_schema: {
51          name: 'resume_extraction',
52          strict: true,
53          schema: {
54            type: 'object',
55            properties: {
56              full_name: { type: 'string' },
57              email: { type: 'string' },
58              phone: { type: 'string' },
59              location: { type: 'string' },
60              summary: { type: 'string' },
61              total_experience_years: { type: 'number' },
62              skills: { type: 'array', items: { type: 'string' } },
63              experiences: {
64                type: 'array',
65                items: {
66                  type: 'object',
67                  properties: {
68                    company: { type: 'string' },
69                    title: { type: 'string' },
70                    start_date: { type: 'string' },
71                    end_date: { type: 'string' },
72                    description: { type: 'string' },
73                  },
74                  required: ['company', 'title', 'start_date', 'end_date', 'description'],
75                  additionalProperties: false,
76                },
77              },
78              education: {
79                type: 'array',
80                items: {
81                  type: 'object',
82                  properties: {
83                    institution: { type: 'string' },
84                    degree: { type: 'string' },
85                    field: { type: 'string' },
86                    year: { type: 'string' },
87                  },
88                  required: ['institution', 'degree', 'field', 'year'],
89                  additionalProperties: false,
90                },
91              },
92            },
93            required: ['full_name', 'email', 'phone', 'location', 'summary', 'total_experience_years', 'skills', 'experiences', 'education'],
94            additionalProperties: false,
95          },
96        },
97      },
98    }),
99  })
100
101  const result = await response.json()
102  const parsed = JSON.parse(result.choices[0].message.content)
103
104  const { data: candidate } = await supabase
105    .from('extracted_candidates')
106    .insert({
107      parsed_resume_id: resume_id,
108      full_name: parsed.full_name,
109      email: parsed.email,
110      phone: parsed.phone,
111      location: parsed.location,
112      summary: parsed.summary,
113      total_experience_years: parsed.total_experience_years,
114      skills: parsed.skills,
115    })
116    .select()
117    .single()
118
119  if (candidate && parsed.experiences) {
120    await supabase.from('extracted_experiences').insert(
121      parsed.experiences.map((exp: any, i: number) => ({
122        candidate_id: candidate.id,
123        ...exp,
124        position: i + 1,
125      }))
126    )
127  }
128
129  if (candidate && parsed.education) {
130    await supabase.from('extracted_education').insert(
131      parsed.education.map((edu: any) => ({
132        candidate_id: candidate.id,
133        ...edu,
134      }))
135    )
136  }
137
138  await supabase.from('parsed_resumes').update({
139    status: 'completed',
140    parsed_data: parsed,
141    confidence_score: 0.85,
142  }).eq('id', resume_id)
143
144  return NextResponse.json({ success: true, candidate_id: candidate?.id })
145}

1// Paste this prompt into V0's AI chat:
2// Build a parsed result page at app/parser/[id]/page.tsx.
3// Requirements:
4// - Fetch the parsed_resume with extracted_candidates, experiences, and education
5// - If status='parsing', show Skeleton loading with "AI is extracting data..." message
6// - If status='completed', show editable result:
7//   - Personal Info Card: Input fields for name, email, phone, location (pre-filled with extracted data)
8//   - Summary Textarea (pre-filled)
9//   - Skills: Badge list with X to remove, Input to add new skills
10//   - Experiences: Cards for each with editable company, title, dates, description Inputs
11//   - Education: Cards for each with editable institution, degree, field, year
12//   - Badge next to each field showing confidence (high=green, medium=yellow, low=red)
13// - "Save Corrections" Button calls Server Action updateParsedField()
14// - "Export JSON" Button downloads the extracted data as a JSON file
15// - If status='failed', show error message with AlertDialog to retry
16// - Use shadcn/ui Card, Input, Badge, Textarea, Separator, Skeleton, Toast