package store import ( "context" "crypto/rand" "database/sql" "encoding/hex" "encoding/json" "errors" "fmt" "sort" "strings" "speech-learning-api/internal/domain" ) var ErrNotFound = errors.New("not found") type PostgresStore struct { db *sql.DB } func NewPostgresStore(db *sql.DB) *PostgresStore { return &PostgresStore{db: db} } func NewID(prefix string) string { var b [12]byte if _, err := rand.Read(b[:]); err != nil { panic(err) } return prefix + "_" + hex.EncodeToString(b[:]) } func (s *PostgresStore) Init(ctx context.Context) error { if _, err := s.db.ExecContext(ctx, schemaSQL); err != nil { return err } for _, stmt := range seedSQL { if _, err := s.db.ExecContext(ctx, stmt); err != nil { return err } } return nil } func (s *PostgresStore) EnsureGeneratedLesson(ctx context.Context, targetLanguage, cefrLevel string) (domain.Lesson, error) { lesson := domain.Lesson{ ID: "les_generated_" + strings.ToLower(strings.ReplaceAll(targetLanguage, "-", "_")) + "_" + strings.ToLower(cefrLevel), TargetLanguage: targetLanguage, CEFRLevel: cefrLevel, Topic: "agent_generated", Title: "Agent generated practice", } row := s.db.QueryRowContext(ctx, ` INSERT INTO lessons (id, target_language, cefr_level, topic, title) VALUES ($1, $2, $3, $4, $5) ON CONFLICT (id) DO UPDATE SET target_language = EXCLUDED.target_language, cefr_level = EXCLUDED.cefr_level, topic = EXCLUDED.topic, title = EXCLUDED.title RETURNING id, target_language, cefr_level, topic, title `, lesson.ID, lesson.TargetLanguage, lesson.CEFRLevel, lesson.Topic, lesson.Title) if err := row.Scan(&lesson.ID, &lesson.TargetLanguage, &lesson.CEFRLevel, &lesson.Topic, &lesson.Title); err != nil { return domain.Lesson{}, err } return lesson, nil } func (s *PostgresStore) SaveGeneratedExercise(ctx context.Context, userID string, generated domain.GeneratedExercise) (domain.Lesson, domain.Exercise, error) { targetLanguage := valueOr(generated.TargetLanguage, "en-US") cefrLevel := valueOr(generated.CEFRLevel, "A1") lesson, err := s.EnsureGeneratedLesson(ctx, targetLanguage, cefrLevel) if err != nil { return domain.Lesson{}, domain.Exercise{}, err } focusPoints, err := json.Marshal(generated.FocusPoints) if err != nil { return domain.Lesson{}, domain.Exercise{}, err } successCriteria, err := json.Marshal(generated.SuccessCriteria) if err != nil { return domain.Lesson{}, domain.Exercise{}, err } exercise := domain.Exercise{ ID: NewID("exg"), LessonID: lesson.ID, TargetLanguage: targetLanguage, CEFRLevel: cefrLevel, Type: valueOr(generated.ExerciseType, "repeat_sentence"), PromptText: valueOr(generated.DisplayPrompt, "Sprich den Satz klar nach."), TargetText: generated.ReferenceText, Difficulty: 1, Source: "flowise", } if strings.TrimSpace(exercise.TargetText) == "" { return domain.Lesson{}, domain.Exercise{}, errors.New("generated exercise reference_text is required") } row := s.db.QueryRowContext(ctx, ` INSERT INTO exercises ( id, lesson_id, target_language, cefr_level, type, prompt_text, target_text, difficulty, source, created_by_user_id, tts_text, focus_points_json, success_criteria_json, reason_for_choice, agent_context_json ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, 'flowise', $9, $10, $11, $12, $13, $14) RETURNING id, lesson_id, target_language, cefr_level, type, prompt_text, target_text, difficulty, source `, exercise.ID, exercise.LessonID, exercise.TargetLanguage, exercise.CEFRLevel, exercise.Type, exercise.PromptText, exercise.TargetText, exercise.Difficulty, userID, generated.TTSText, string(focusPoints), string(successCriteria), generated.ReasonForChoice, mustJSON(generated)) if err := row.Scan(&exercise.ID, &exercise.LessonID, &exercise.TargetLanguage, &exercise.CEFRLevel, &exercise.Type, &exercise.PromptText, &exercise.TargetText, &exercise.Difficulty, &exercise.Source); err != nil { return domain.Lesson{}, domain.Exercise{}, err } return lesson, exercise, nil } func (s *PostgresStore) DebugStatus(ctx context.Context) domain.DebugDBStatus { status := domain.DebugDBStatus{ Counts: map[string]int{}, } if err := s.db.PingContext(ctx); err != nil { status.Error = err.Error() return status } status.OK = true for _, table := range []string{"users", "learner_profiles", "language_profiles", "lessons", "exercises", "attempts", "conversation_sessions"} { var count int if err := s.db.QueryRowContext(ctx, fmt.Sprintf("SELECT COUNT(*) FROM %s", table)).Scan(&count); err != nil { status.OK = false status.Error = err.Error() return status } status.Counts[table] = count } _ = s.db.QueryRowContext(ctx, `SELECT COUNT(*) FROM language_profiles WHERE code = 'en-US'`).Scan(&status.SeedLanguageCount) _ = s.db.QueryRowContext(ctx, `SELECT COUNT(*) FROM exercises WHERE target_language = 'en-US' AND cefr_level = 'A1'`).Scan(&status.SeedExerciseCount) return status } func (s *PostgresStore) CreateUser(ctx context.Context, email, passwordHash, uiLanguage string) (domain.User, error) { user := domain.User{ID: NewID("usr"), Email: strings.ToLower(strings.TrimSpace(email)), UILanguage: uiLanguage} row := s.db.QueryRowContext(ctx, ` INSERT INTO users (id, email, password_hash, ui_language) VALUES ($1, $2, $3, $4) RETURNING id, email, ui_language, created_at `, user.ID, user.Email, passwordHash, uiLanguage) if err := row.Scan(&user.ID, &user.Email, &user.UILanguage, &user.CreatedAt); err != nil { return domain.User{}, err } return user, nil } func (s *PostgresStore) GetPasswordHashByEmail(ctx context.Context, email string) (domain.User, string, error) { var user domain.User var hash string row := s.db.QueryRowContext(ctx, ` SELECT id, email, password_hash, ui_language, created_at FROM users WHERE email = $1 `, strings.ToLower(strings.TrimSpace(email))) if err := row.Scan(&user.ID, &user.Email, &hash, &user.UILanguage, &user.CreatedAt); err != nil { if errors.Is(err, sql.ErrNoRows) { return domain.User{}, "", ErrNotFound } return domain.User{}, "", err } return user, hash, nil } func (s *PostgresStore) GetUser(ctx context.Context, id string) (domain.User, error) { var user domain.User row := s.db.QueryRowContext(ctx, ` SELECT id, email, ui_language, created_at FROM users WHERE id = $1 `, id) if err := row.Scan(&user.ID, &user.Email, &user.UILanguage, &user.CreatedAt); err != nil { if errors.Is(err, sql.ErrNoRows) { return domain.User{}, ErrNotFound } return domain.User{}, err } return user, nil } func (s *PostgresStore) CreateLearnerProfile(ctx context.Context, userID, targetLanguage, cefrLevel string, dailyGoalMinutes int) (domain.LearnerProfile, error) { profile := domain.LearnerProfile{ ID: NewID("lrn"), UserID: userID, TargetLanguage: targetLanguage, CEFRLevel: cefrLevel, DailyGoalMinutes: dailyGoalMinutes, } row := s.db.QueryRowContext(ctx, ` INSERT INTO learner_profiles (id, user_id, target_language, cefr_level, daily_goal_minutes) VALUES ($1, $2, $3, $4, $5) ON CONFLICT (user_id, target_language) DO UPDATE SET cefr_level = EXCLUDED.cefr_level, daily_goal_minutes = EXCLUDED.daily_goal_minutes RETURNING id, user_id, target_language, cefr_level, daily_goal_minutes, created_at `, profile.ID, userID, targetLanguage, cefrLevel, dailyGoalMinutes) if err := row.Scan(&profile.ID, &profile.UserID, &profile.TargetLanguage, &profile.CEFRLevel, &profile.DailyGoalMinutes, &profile.CreatedAt); err != nil { return domain.LearnerProfile{}, err } return profile, nil } func (s *PostgresStore) GetPrimaryProfile(ctx context.Context, userID string) (domain.LearnerProfile, error) { var p domain.LearnerProfile row := s.db.QueryRowContext(ctx, ` SELECT id, user_id, target_language, cefr_level, daily_goal_minutes, created_at FROM learner_profiles WHERE user_id = $1 ORDER BY created_at LIMIT 1 `, userID) if err := row.Scan(&p.ID, &p.UserID, &p.TargetLanguage, &p.CEFRLevel, &p.DailyGoalMinutes, &p.CreatedAt); err != nil { if errors.Is(err, sql.ErrNoRows) { return domain.LearnerProfile{}, ErrNotFound } return domain.LearnerProfile{}, err } return p, nil } func (s *PostgresStore) UpdatePreferences(ctx context.Context, userID, uiLanguage, targetLanguage, cefrLevel string, dailyGoalMinutes int) (domain.LearnerProfile, error) { if uiLanguage != "" { if _, err := s.db.ExecContext(ctx, `UPDATE users SET ui_language = $1 WHERE id = $2`, uiLanguage, userID); err != nil { return domain.LearnerProfile{}, err } } if dailyGoalMinutes <= 0 { dailyGoalMinutes = 10 } return s.CreateLearnerProfile(ctx, userID, valueOr(targetLanguage, "en-US"), valueOr(cefrLevel, "A1"), dailyGoalMinutes) } func (s *PostgresStore) ListLanguages(ctx context.Context) ([]domain.LanguageProfile, error) { rows, err := s.db.QueryContext(ctx, ` SELECT code, display_name, azure_locale, default_tts_voice, voices_json, supports_pronunciation_assessment, supports_prosody FROM language_profiles ORDER BY code `) if err != nil { return nil, err } defer rows.Close() var out []domain.LanguageProfile for rows.Next() { item, err := scanLanguage(rows) if err != nil { return nil, err } out = append(out, item) } return out, rows.Err() } func (s *PostgresStore) GetLanguage(ctx context.Context, code string) (domain.LanguageProfile, error) { row := s.db.QueryRowContext(ctx, ` SELECT code, display_name, azure_locale, default_tts_voice, voices_json, supports_pronunciation_assessment, supports_prosody FROM language_profiles WHERE code = $1 `, code) lang, err := scanLanguage(row) if err != nil { if errors.Is(err, sql.ErrNoRows) { return domain.LanguageProfile{}, ErrNotFound } return domain.LanguageProfile{}, err } return lang, nil } func (s *PostgresStore) NextLessonAndExercise(ctx context.Context, profile domain.LearnerProfile, avoidReferenceText ...string) (domain.Lesson, domain.Exercise, error) { var lesson domain.Lesson var exercise domain.Exercise row := s.db.QueryRowContext(ctx, ` SELECT l.id, l.target_language, l.cefr_level, l.topic, l.title, e.id, e.lesson_id, e.target_language, e.cefr_level, e.type, e.prompt_text, e.target_text, e.difficulty, COALESCE(e.source, 'seed') FROM exercises e JOIN lessons l ON l.id = e.lesson_id WHERE e.target_language = $1 AND e.cefr_level = $2 AND COALESCE(e.source, 'seed') = 'seed' AND NOT EXISTS ( SELECT 1 FROM jsonb_array_elements_text($4::jsonb) AS avoided(sentence) WHERE lower(trim(avoided.sentence)) = lower(trim(e.target_text)) ) ORDER BY ( SELECT COUNT(*) FROM attempts a WHERE a.exercise_id = e.id AND a.user_id = $3 ), e.difficulty, e.id LIMIT 1 `, profile.TargetLanguage, profile.CEFRLevel, profile.UserID, mustJSON(avoidReferenceText)) if err := row.Scan( &lesson.ID, &lesson.TargetLanguage, &lesson.CEFRLevel, &lesson.Topic, &lesson.Title, &exercise.ID, &exercise.LessonID, &exercise.TargetLanguage, &exercise.CEFRLevel, &exercise.Type, &exercise.PromptText, &exercise.TargetText, &exercise.Difficulty, &exercise.Source, ); err != nil { if errors.Is(err, sql.ErrNoRows) { return domain.Lesson{}, domain.Exercise{}, ErrNotFound } return domain.Lesson{}, domain.Exercise{}, err } return lesson, exercise, nil } func (s *PostgresStore) GetExercise(ctx context.Context, id, userID string) (domain.Exercise, error) { var e domain.Exercise row := s.db.QueryRowContext(ctx, ` SELECT id, lesson_id, target_language, cefr_level, type, prompt_text, target_text, difficulty, COALESCE(source, 'seed') FROM exercises WHERE id = $1 AND (COALESCE(source, 'seed') = 'seed' OR created_by_user_id = $2) `, id, userID) if err := row.Scan(&e.ID, &e.LessonID, &e.TargetLanguage, &e.CEFRLevel, &e.Type, &e.PromptText, &e.TargetText, &e.Difficulty, &e.Source); err != nil { if errors.Is(err, sql.ErrNoRows) { return domain.Exercise{}, ErrNotFound } return domain.Exercise{}, err } return e, nil } func (s *PostgresStore) SaveAttempt(ctx context.Context, attempt domain.Attempt) (domain.Attempt, error) { if attempt.ID == "" { attempt.ID = NewID("att") } wordScores, err := json.Marshal(attempt.WordScores) if err != nil { return domain.Attempt{}, err } row := s.db.QueryRowContext(ctx, ` INSERT INTO attempts ( id, user_id, exercise_id, target_language, recognized_text, overall_score, accuracy_score, fluency_score, completeness_score, prosody_score, word_scores_json, teacher_feedback ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12) RETURNING created_at `, attempt.ID, attempt.UserID, attempt.ExerciseID, attempt.TargetLanguage, attempt.RecognizedText, attempt.OverallScore, attempt.AccuracyScore, attempt.FluencyScore, attempt.CompletenessScore, attempt.ProsodyScore, string(wordScores), attempt.TeacherFeedback) if err := row.Scan(&attempt.CreatedAt); err != nil { return domain.Attempt{}, err } return attempt, nil } func (s *PostgresStore) Progress(ctx context.Context, userID string, limit int) (domain.ProgressSummary, error) { if limit <= 0 { limit = 10 } var summary domain.ProgressSummary if err := s.db.QueryRowContext(ctx, ` SELECT COUNT(*), COALESCE(AVG(overall_score), 0) FROM attempts WHERE user_id = $1 `, userID).Scan(&summary.TotalAttempts, &summary.AverageScore); err != nil { return domain.ProgressSummary{}, err } profile, err := s.GetPrimaryProfile(ctx, userID) if err == nil { summary.DailyGoalMinutes = profile.DailyGoalMinutes } rows, err := s.db.QueryContext(ctx, ` SELECT id, user_id, exercise_id, target_language, recognized_text, overall_score, accuracy_score, fluency_score, completeness_score, prosody_score, word_scores_json, teacher_feedback, created_at FROM attempts WHERE user_id = $1 ORDER BY created_at DESC LIMIT $2 `, userID, limit) if err != nil { return domain.ProgressSummary{}, err } defer rows.Close() for rows.Next() { attempt, err := scanAttempt(rows) if err != nil { return domain.ProgressSummary{}, err } summary.RecentAttempts = append(summary.RecentAttempts, attempt) } if err := rows.Err(); err != nil { return domain.ProgressSummary{}, err } summary.WeakWords = latestWeakWords(summary.RecentAttempts) summary.WeakPhonemes = latestWeakPhonemes(summary.RecentAttempts) return summary, nil } // RecentAttempts are ordered newest first. A newer successful score clears an // older weak score for the same word within the progress window. func latestWeakWords(attempts []domain.Attempt) []domain.WordScore { seen := make(map[string]bool) var weak []domain.WordScore for _, attempt := range attempts { for _, word := range attempt.WordScores { key := strings.ToLower(strings.TrimSpace(word.Word)) if key == "" || seen[key] { continue } seen[key] = true if word.Accuracy < 75 { weak = append(weak, word) } } } return weak } // Keep the newest scored occurrence for each word and phoneme. Within one // attempt, use the lowest score if the same sound occurs more than once. func latestWeakPhonemes(attempts []domain.Attempt) []domain.WeakPhoneme { seen := make(map[string]bool) var weak []domain.WeakPhoneme for _, attempt := range attempts { current := make(map[string]domain.WeakPhoneme) for _, word := range attempt.WordScores { if strings.EqualFold(word.ErrorType, "Omission") { continue } wordKey := strings.ToLower(strings.TrimSpace(word.Word)) if wordKey == "" { continue } for _, phoneme := range word.PhonemeScores { name := strings.TrimSpace(phoneme.Phoneme) if name == "" { continue } key := wordKey + "\x00" + name if seen[key] { continue } if previous, ok := current[key]; !ok || phoneme.Accuracy < previous.Accuracy { current[key] = domain.WeakPhoneme{Word: word.Word, Phoneme: name, Accuracy: phoneme.Accuracy} } } } for key, score := range current { seen[key] = true if score.Accuracy < 75 { weak = append(weak, score) } } } sort.Slice(weak, func(i, j int) bool { if weak[i].Accuracy == weak[j].Accuracy { if weak[i].Word == weak[j].Word { return weak[i].Phoneme < weak[j].Phoneme } return weak[i].Word < weak[j].Word } return weak[i].Accuracy < weak[j].Accuracy }) if len(weak) > 12 { weak = weak[:12] } return weak } func (s *PostgresStore) CreateConversationSession(ctx context.Context, userID, targetLanguage, cefrLevel string) (domain.ConversationSession, error) { session := domain.ConversationSession{ ID: NewID("con"), UserID: userID, TargetLanguage: targetLanguage, CEFRLevel: cefrLevel, Status: "active", } row := s.db.QueryRowContext(ctx, ` INSERT INTO conversation_sessions (id, user_id, target_language, cefr_level, status) VALUES ($1, $2, $3, $4, $5) RETURNING created_at `, session.ID, session.UserID, session.TargetLanguage, session.CEFRLevel, session.Status) if err := row.Scan(&session.CreatedAt); err != nil { return domain.ConversationSession{}, err } return session, nil } func (s *PostgresStore) SaveConversationTurn(ctx context.Context, turn domain.ConversationTurn) (domain.ConversationTurn, error) { if turn.ID == "" { turn.ID = NewID("trn") } row := s.db.QueryRowContext(ctx, ` INSERT INTO conversation_turns (id, session_id, speaker, text, attempt_id) VALUES ($1, $2, $3, $4, NULLIF($5, '')) RETURNING created_at `, turn.ID, turn.SessionID, turn.Speaker, turn.Text, turn.AttemptID) if err := row.Scan(&turn.CreatedAt); err != nil { return domain.ConversationTurn{}, err } return turn, nil } func scanLanguage(scanner interface{ Scan(dest ...any) error }) (domain.LanguageProfile, error) { var lang domain.LanguageProfile var voicesRaw []byte if err := scanner.Scan( &lang.Code, &lang.DisplayName, &lang.AzureLocale, &lang.DefaultTTSVoice, &voicesRaw, &lang.SupportsPronunciationAssessment, &lang.SupportsProsody, ); err != nil { return domain.LanguageProfile{}, err } if err := json.Unmarshal(voicesRaw, &lang.Voices); err != nil { return domain.LanguageProfile{}, err } return lang, nil } func scanAttempt(scanner interface{ Scan(dest ...any) error }) (domain.Attempt, error) { var attempt domain.Attempt var wordsRaw []byte if err := scanner.Scan( &attempt.ID, &attempt.UserID, &attempt.ExerciseID, &attempt.TargetLanguage, &attempt.RecognizedText, &attempt.OverallScore, &attempt.AccuracyScore, &attempt.FluencyScore, &attempt.CompletenessScore, &attempt.ProsodyScore, &wordsRaw, &attempt.TeacherFeedback, &attempt.CreatedAt, ); err != nil { return domain.Attempt{}, err } if len(wordsRaw) > 0 { _ = json.Unmarshal(wordsRaw, &attempt.WordScores) } return attempt, nil } func valueOr(value, fallback string) string { if strings.TrimSpace(value) == "" { return fallback } return value } func mustJSON(value any) string { body, err := json.Marshal(value) if err != nil { return "{}" } return string(body) } const schemaSQL = ` CREATE TABLE IF NOT EXISTS users ( id TEXT PRIMARY KEY, email TEXT NOT NULL UNIQUE, password_hash TEXT NOT NULL, ui_language TEXT NOT NULL DEFAULT 'de-DE', created_at TIMESTAMPTZ NOT NULL DEFAULT now() ); CREATE TABLE IF NOT EXISTS learner_profiles ( id TEXT PRIMARY KEY, user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE, target_language TEXT NOT NULL, cefr_level TEXT NOT NULL DEFAULT 'A1', daily_goal_minutes INT NOT NULL DEFAULT 10, created_at TIMESTAMPTZ NOT NULL DEFAULT now(), UNIQUE (user_id, target_language) ); CREATE TABLE IF NOT EXISTS language_profiles ( code TEXT PRIMARY KEY, display_name TEXT NOT NULL, azure_locale TEXT NOT NULL, default_tts_voice TEXT NOT NULL, voices_json JSONB NOT NULL DEFAULT '[]'::jsonb, supports_pronunciation_assessment BOOLEAN NOT NULL DEFAULT true, supports_prosody BOOLEAN NOT NULL DEFAULT true ); CREATE TABLE IF NOT EXISTS lessons ( id TEXT PRIMARY KEY, target_language TEXT NOT NULL, cefr_level TEXT NOT NULL, topic TEXT NOT NULL, title TEXT NOT NULL ); CREATE TABLE IF NOT EXISTS exercises ( id TEXT PRIMARY KEY, lesson_id TEXT NOT NULL REFERENCES lessons(id) ON DELETE CASCADE, target_language TEXT NOT NULL, cefr_level TEXT NOT NULL, type TEXT NOT NULL, prompt_text TEXT NOT NULL, target_text TEXT NOT NULL, difficulty INT NOT NULL DEFAULT 1, source TEXT NOT NULL DEFAULT 'seed', created_by_user_id TEXT REFERENCES users(id) ON DELETE SET NULL, tts_text TEXT NOT NULL DEFAULT '', focus_points_json JSONB NOT NULL DEFAULT '[]'::jsonb, success_criteria_json JSONB NOT NULL DEFAULT '[]'::jsonb, reason_for_choice TEXT NOT NULL DEFAULT '', agent_context_json JSONB NOT NULL DEFAULT '{}'::jsonb, created_at TIMESTAMPTZ NOT NULL DEFAULT now() ); ALTER TABLE exercises ADD COLUMN IF NOT EXISTS source TEXT NOT NULL DEFAULT 'seed'; ALTER TABLE exercises ADD COLUMN IF NOT EXISTS created_by_user_id TEXT REFERENCES users(id) ON DELETE SET NULL; ALTER TABLE exercises ADD COLUMN IF NOT EXISTS tts_text TEXT NOT NULL DEFAULT ''; ALTER TABLE exercises ADD COLUMN IF NOT EXISTS focus_points_json JSONB NOT NULL DEFAULT '[]'::jsonb; ALTER TABLE exercises ADD COLUMN IF NOT EXISTS success_criteria_json JSONB NOT NULL DEFAULT '[]'::jsonb; ALTER TABLE exercises ADD COLUMN IF NOT EXISTS reason_for_choice TEXT NOT NULL DEFAULT ''; ALTER TABLE exercises ADD COLUMN IF NOT EXISTS agent_context_json JSONB NOT NULL DEFAULT '{}'::jsonb; ALTER TABLE exercises ADD COLUMN IF NOT EXISTS created_at TIMESTAMPTZ NOT NULL DEFAULT now(); CREATE TABLE IF NOT EXISTS attempts ( id TEXT PRIMARY KEY, user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE, exercise_id TEXT NOT NULL REFERENCES exercises(id) ON DELETE CASCADE, target_language TEXT NOT NULL, recognized_text TEXT NOT NULL, overall_score DOUBLE PRECISION NOT NULL, accuracy_score DOUBLE PRECISION NOT NULL, fluency_score DOUBLE PRECISION NOT NULL, completeness_score DOUBLE PRECISION NOT NULL, prosody_score DOUBLE PRECISION NOT NULL, word_scores_json JSONB NOT NULL DEFAULT '[]'::jsonb, teacher_feedback TEXT NOT NULL DEFAULT '', created_at TIMESTAMPTZ NOT NULL DEFAULT now() ); CREATE TABLE IF NOT EXISTS progress_events ( id TEXT PRIMARY KEY, user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE, target_language TEXT NOT NULL, event_type TEXT NOT NULL, payload_json JSONB NOT NULL DEFAULT '{}'::jsonb, created_at TIMESTAMPTZ NOT NULL DEFAULT now() ); CREATE TABLE IF NOT EXISTS conversation_sessions ( id TEXT PRIMARY KEY, user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE, target_language TEXT NOT NULL, cefr_level TEXT NOT NULL, status TEXT NOT NULL DEFAULT 'active', created_at TIMESTAMPTZ NOT NULL DEFAULT now() ); CREATE TABLE IF NOT EXISTS conversation_turns ( id TEXT PRIMARY KEY, session_id TEXT NOT NULL REFERENCES conversation_sessions(id) ON DELETE CASCADE, speaker TEXT NOT NULL, text TEXT NOT NULL, attempt_id TEXT REFERENCES attempts(id) ON DELETE SET NULL, created_at TIMESTAMPTZ NOT NULL DEFAULT now() ); CREATE INDEX IF NOT EXISTS idx_attempts_user_created ON attempts(user_id, created_at DESC); CREATE INDEX IF NOT EXISTS idx_exercises_language_level ON exercises(target_language, cefr_level); ` var seedSQL = []string{ `INSERT INTO language_profiles ( code, display_name, azure_locale, default_tts_voice, voices_json, supports_pronunciation_assessment, supports_prosody ) VALUES ( 'en-US', 'English (United States)', 'en-US', 'en-US-JennyNeural', '["en-US-JennyNeural", "en-US-GuyNeural", "en-US-AriaNeural"]'::jsonb, true, true ) ON CONFLICT (code) DO UPDATE SET display_name = EXCLUDED.display_name, azure_locale = EXCLUDED.azure_locale, default_tts_voice = EXCLUDED.default_tts_voice, voices_json = EXCLUDED.voices_json`, `INSERT INTO language_profiles ( code, display_name, azure_locale, default_tts_voice, voices_json, supports_pronunciation_assessment, supports_prosody ) VALUES ( 'es-ES', 'Spanish (Spain)', 'es-ES', 'es-ES-ElviraNeural', '["es-ES-ElviraNeural", "es-ES-AlvaroNeural"]'::jsonb, true, true ) ON CONFLICT (code) DO NOTHING`, `INSERT INTO lessons (id, target_language, cefr_level, topic, title) VALUES ('les_a1_intro', 'en-US', 'A1', 'introductions', 'Introduce yourself'), ('les_a1_cafe', 'en-US', 'A1', 'cafe', 'Order a coffee'), ('les_a1_numbers', 'en-US', 'A1', 'numbers', 'Numbers and names') ON CONFLICT (id) DO UPDATE SET title = EXCLUDED.title`, `INSERT INTO exercises (id, lesson_id, target_language, cefr_level, type, prompt_text, target_text, difficulty) VALUES ('ex_a1_hello', 'les_a1_intro', 'en-US', 'A1', 'repeat_sentence', 'Sprich den Satz klar nach.', 'Hello, my name is Anna.', 1), ('ex_a1_from', 'les_a1_intro', 'en-US', 'A1', 'repeat_sentence', 'Achte auf den Rhythmus im Satz.', 'I am from Berlin.', 1), ('ex_a1_coffee', 'les_a1_cafe', 'en-US', 'A1', 'repeat_sentence', 'Sprich langsam und deutlich.', 'Can I have a coffee, please?', 2), ('ex_a1_water', 'les_a1_cafe', 'en-US', 'A1', 'repeat_sentence', 'Achte auf die Endlaute.', 'I would like some water.', 2), ('ex_a1_phone', 'les_a1_numbers', 'en-US', 'A1', 'repeat_sentence', 'Sprich jede Zahl einzeln sauber.', 'My phone number is five, two, nine.', 2) ON CONFLICT (id) DO UPDATE SET prompt_text = EXCLUDED.prompt_text, target_text = EXCLUDED.target_text, difficulty = EXCLUDED.difficulty`, } func DebugSQL(name string, err error) error { if err == nil { return nil } return fmt.Errorf("%s: %w", name, err) }