mirror of
https://github.com/lucasrcsantana/story-generator.git
synced 2025-12-16 21:37:51 +00:00
289 lines
8.7 KiB
TypeScript
289 lines
8.7 KiB
TypeScript
import { serve } from 'https://deno.land/std@0.168.0/http/server.ts'
|
|
import { createClient } from 'https://esm.sh/@supabase/supabase-js@2'
|
|
import { processAudioWithWhisper } from './whisper.ts'
|
|
import { analyzeReading } from './analyzer.ts'
|
|
import { createLogger } from './logger.ts'
|
|
|
|
const corsHeaders = {
|
|
'Access-Control-Allow-Origin': '*',
|
|
'Access-Control-Allow-Headers': 'authorization, x-client-info, apikey, content-type',
|
|
}
|
|
|
|
interface AudioRecord {
|
|
id: string
|
|
story_id: string
|
|
student_id: string
|
|
audio_url: string
|
|
status: 'pending_analysis' | 'processing' | 'completed' | 'error'
|
|
analysis: any
|
|
created_at: string
|
|
transcription: string | null
|
|
processed_at: string | null
|
|
error_message: string | null
|
|
fluency_score: number | null
|
|
pronunciation_score: number | null
|
|
accuracy_score: number | null
|
|
comprehension_score: number | null
|
|
words_per_minute: number | null
|
|
pause_count: number | null
|
|
error_count: number | null
|
|
self_corrections: number | null
|
|
strengths: string[]
|
|
improvements: string[]
|
|
suggestions: string | null
|
|
}
|
|
|
|
// Função principal de processamento
|
|
async function processAudioRecord(audioRecord: AudioRecord, logger: any) {
|
|
const supabase = createClient(
|
|
Deno.env.get('SUPABASE_URL') ?? '',
|
|
Deno.env.get('SUPABASE_SERVICE_ROLE_KEY') ?? ''
|
|
)
|
|
|
|
// 1. Verifica e atualiza status para processing
|
|
logger.info('status_update_start', 'Verificando e atualizando registro')
|
|
|
|
// Primeiro verifica se o registro existe
|
|
const { data: existingRecord, error: checkError } = await supabase
|
|
.from('story_recordings')
|
|
.select('id, status')
|
|
.eq('id', audioRecord.id)
|
|
.maybeSingle()
|
|
|
|
logger.info('query_debug', 'Resultado da query', {
|
|
hasData: !!existingRecord,
|
|
recordId: audioRecord.id,
|
|
record: existingRecord,
|
|
error: checkError?.message
|
|
})
|
|
|
|
if (checkError) {
|
|
logger.error('check_error', checkError)
|
|
throw new Error(`Erro ao verificar registro: ${checkError.message}`)
|
|
}
|
|
|
|
if (!existingRecord) {
|
|
// Se não existe, tenta criar
|
|
logger.info('record_create', 'Tentando criar registro', audioRecord)
|
|
|
|
const { error: insertError } = await supabase
|
|
.from('story_recordings')
|
|
.insert({
|
|
id: audioRecord.id,
|
|
story_id: audioRecord.story_id,
|
|
student_id: audioRecord.student_id,
|
|
audio_url: audioRecord.audio_url,
|
|
status: 'pending_analysis',
|
|
created_at: new Date().toISOString()
|
|
})
|
|
|
|
if (insertError) {
|
|
logger.error('record_create_error', insertError)
|
|
throw new Error(`Erro ao criar registro: ${insertError.message}`)
|
|
}
|
|
}
|
|
|
|
// Atualiza para processing
|
|
const { error: processingError } = await supabase
|
|
.from('story_recordings')
|
|
.update({
|
|
status: 'processing',
|
|
processed_at: new Date().toISOString()
|
|
})
|
|
.eq('id', audioRecord.id)
|
|
|
|
if (processingError) {
|
|
logger.error('processing_status_error', processingError)
|
|
throw processingError
|
|
}
|
|
|
|
logger.info('status_updated', 'Status atualizado para processing', { id: audioRecord.id })
|
|
|
|
// 2. Processamento do áudio
|
|
logger.info('processing_start', 'Iniciando processamento do áudio')
|
|
const transcription = await processAudioWithWhisper(audioRecord.audio_url, logger)
|
|
logger.info('transcription_complete', 'Transcrição concluída', { length: transcription?.length || 0 })
|
|
|
|
// 3. Análise do áudio
|
|
const analysis = await analyzeReading(transcription, audioRecord.story_id, logger)
|
|
logger.info('analysis_complete', 'Análise concluída', { scores: analysis })
|
|
|
|
// 4. Prepara dados para atualização
|
|
const updateData = {
|
|
status: 'completed',
|
|
transcription: transcription || '',
|
|
processed_at: new Date().toISOString(),
|
|
fluency_score: Number(analysis.fluency_score) || 0,
|
|
pronunciation_score: Number(analysis.pronunciation_score) || 0,
|
|
accuracy_score: Number(analysis.accuracy_score) || 0,
|
|
comprehension_score: Number(analysis.comprehension_score) || 0,
|
|
words_per_minute: Number(analysis.words_per_minute) || 0,
|
|
pause_count: Number(analysis.pause_count) || 0,
|
|
error_count: Number(analysis.error_count) || 0,
|
|
self_corrections: Number(analysis.self_corrections) || 0,
|
|
strengths: Array.isArray(analysis.strengths) ? analysis.strengths : [],
|
|
improvements: Array.isArray(analysis.improvements) ? analysis.improvements : [],
|
|
suggestions: analysis.suggestions || ''
|
|
}
|
|
|
|
logger.info('update_start', 'Iniciando atualização no banco', updateData)
|
|
|
|
// 5. Verifica se o registro existe antes do update
|
|
const { data: preUpdateCheck, error: preCheckError } = await supabase
|
|
.from('story_recordings')
|
|
.select('id, status')
|
|
.eq('id', audioRecord.id)
|
|
.limit(1)
|
|
|
|
if (preCheckError) {
|
|
logger.error('pre_check_error', preCheckError)
|
|
throw preCheckError
|
|
}
|
|
|
|
if (!preUpdateCheck || preUpdateCheck.length === 0) {
|
|
const error = new Error(`Registro ${audioRecord.id} não encontrado antes do update`)
|
|
logger.error('pre_update_check_error', error)
|
|
throw error
|
|
}
|
|
|
|
logger.info('pre_update_check', 'Registro encontrado antes do update', preUpdateCheck[0])
|
|
|
|
// Realiza o update
|
|
const { data: updateResult, error: updateError } = await supabase
|
|
.from('story_recordings')
|
|
.update(updateData)
|
|
.eq('id', audioRecord.id)
|
|
.select()
|
|
|
|
if (updateError) {
|
|
logger.error('update_error', updateError, { id: audioRecord.id })
|
|
throw updateError
|
|
}
|
|
|
|
logger.info('update_result', 'Resultado do update', {
|
|
hasData: !!updateResult,
|
|
dataLength: updateResult?.length || 0,
|
|
updateData
|
|
})
|
|
|
|
// Verifica novamente após o update
|
|
const { data: verifyData, error: verifyError } = await supabase
|
|
.from('story_recordings')
|
|
.select('*')
|
|
.eq('id', audioRecord.id)
|
|
.limit(1)
|
|
|
|
logger.info('verify_result', 'Resultado da verificação', {
|
|
hasData: !!verifyData,
|
|
dataLength: verifyData?.length || 0,
|
|
firstRecord: verifyData?.[0]?.id
|
|
})
|
|
|
|
if (verifyError) {
|
|
logger.error('verify_error', verifyError)
|
|
throw verifyError
|
|
}
|
|
|
|
if (!verifyData || verifyData.length === 0) {
|
|
const error = new Error(`Registro ${audioRecord.id} não encontrado após atualização`)
|
|
logger.error('update_validation_error', error)
|
|
throw error
|
|
}
|
|
|
|
const updatedData = verifyData[0]
|
|
|
|
logger.info('update_complete', 'Atualização concluída com sucesso', {
|
|
success: true,
|
|
updatedData
|
|
})
|
|
|
|
return { analysis, updatedData }
|
|
}
|
|
|
|
// Handler principal da Edge Function
|
|
serve(async (req) => {
|
|
let logger: any = null
|
|
let data: { record: AudioRecord } | null = null
|
|
|
|
if (req.method === 'OPTIONS') {
|
|
return new Response('ok', { headers: corsHeaders })
|
|
}
|
|
|
|
try {
|
|
data = await req.json()
|
|
logger = createLogger(data?.record?.id || 'unknown')
|
|
|
|
logger.info('request_received', 'Iniciando processamento', {
|
|
headers: Object.fromEntries(req.headers.entries())
|
|
})
|
|
|
|
// Validação
|
|
if (!data?.record?.id || !data?.record?.audio_url) {
|
|
const error = new Error('Dados inválidos: ID ou URL do áudio ausentes')
|
|
logger.error('validation_error', error)
|
|
throw error
|
|
}
|
|
|
|
logger.info('id_debug', 'Verificando ID', {
|
|
id: data.record.id,
|
|
idType: typeof data.record.id,
|
|
idLength: data.record.id.length,
|
|
isValidUUID: /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(data.record.id)
|
|
});
|
|
|
|
const result = await processAudioRecord(data.record, logger)
|
|
|
|
return new Response(
|
|
JSON.stringify({
|
|
message: 'Áudio processado com sucesso',
|
|
data: result.analysis
|
|
}),
|
|
{
|
|
headers: { ...corsHeaders, 'Content-Type': 'application/json' },
|
|
status: 200,
|
|
}
|
|
)
|
|
|
|
} catch (error) {
|
|
logger?.error('processing_error', error)
|
|
console.error('Erro ao processar áudio:', error)
|
|
|
|
try {
|
|
if (data?.record?.id) {
|
|
const supabase = createClient(
|
|
Deno.env.get('SUPABASE_URL') ?? '',
|
|
Deno.env.get('SUPABASE_SERVICE_ROLE_KEY') ?? '',
|
|
{
|
|
auth: {
|
|
persistSession: false
|
|
}
|
|
}
|
|
)
|
|
|
|
logger?.info('error_status_update_start', 'Atualizando status para error')
|
|
|
|
await supabase
|
|
.from('story_recordings')
|
|
.update({
|
|
status: 'error',
|
|
error_message: error.message || 'Erro desconhecido'
|
|
})
|
|
.eq('id', data.record.id)
|
|
}
|
|
} catch (updateError) {
|
|
logger?.error('error_status_update_failed', updateError)
|
|
console.error('Erro ao atualizar registro com status de erro:', updateError)
|
|
}
|
|
|
|
return new Response(
|
|
JSON.stringify({
|
|
error: 'Falha ao processar áudio',
|
|
details: error.message || 'Erro desconhecido'
|
|
}),
|
|
{
|
|
headers: { ...corsHeaders, 'Content-Type': 'application/json' },
|
|
status: 500,
|
|
}
|
|
)
|
|
}
|
|
}) |