Spaces:
Running
Running
| import type { | |
| AssessmentPackV2, | |
| AssessmentGenerationContextV2, | |
| AssessmentResultV2, | |
| AssessmentSubmissionV2, | |
| CertificateDetailsV2, | |
| CertificationTrack, | |
| HealthStatusV2, | |
| GeneratedCourseV2, | |
| GeneratedProjectV2, | |
| GitHubValidationReportV2, | |
| IssuedCertificateV2, | |
| PaymentRequestResponseV2, | |
| ProjectEvaluationV2, | |
| PublicProfileV2, | |
| SmartQuestionV2, | |
| FreeCourseItem, | |
| FreeCourseCompletionPayload, | |
| YtAnalyzeResponse, | |
| YtAssessmentStartResponse, | |
| YtAssessmentGradeResult, | |
| } from '../types/getcertV2'; | |
| import { supabase } from './supabase'; | |
| import { DEFAULT_FREE_COURSES } from '../constants/defaultFreeCourses'; | |
| type ApiEnvelope<T> = { | |
| success: boolean; | |
| data?: T; | |
| error?: string; | |
| details?: unknown; | |
| }; | |
| const API_BASE_URL = (import.meta.env.VITE_API_BASE_URL || '').trim().replace(/\/$/, ''); | |
| function parsePositiveTimeoutMs(value: unknown, fallbackMs: number): number { | |
| const parsed = Number(value); | |
| if (!Number.isFinite(parsed) || parsed <= 0) { | |
| return fallbackMs; | |
| } | |
| return Math.round(parsed); | |
| } | |
| const API_REQUEST_TIMEOUT_MS = parsePositiveTimeoutMs(import.meta.env.VITE_API_REQUEST_TIMEOUT_MS, 120000); | |
| function normalizePath(path: string): string { | |
| return path.startsWith('/') ? path : `/${path}`; | |
| } | |
| function joinBaseAndPath(base: string, path: string): string { | |
| const normalizedPath = normalizePath(path); | |
| // Backward-compatible guard: if base already ends with /api and callers | |
| // pass /api/... paths, avoid constructing /api/api/... | |
| if (base.endsWith('/api') && normalizedPath.startsWith('/api/')) { | |
| return `${base}${normalizedPath.slice(4)}`; | |
| } | |
| return `${base}${normalizedPath}`; | |
| } | |
| function buildUrl(path: string): string { | |
| if (/^https?:\/\//i.test(path)) { | |
| return path; | |
| } | |
| if (!API_BASE_URL) { | |
| return normalizePath(path); | |
| } | |
| return joinBaseAndPath(API_BASE_URL, path); | |
| } | |
| function getNetworkErrorMessage(error: unknown): string { | |
| const message = error instanceof Error ? error.message : 'Unknown network error'; | |
| return `Unable to reach API endpoint. ${message}. In local dev, run both frontend and API servers (npm run dev:full) or verify VITE_API_BASE_URL.`; | |
| } | |
| async function getAuthorizationHeader(): Promise<Record<string, string>> { | |
| try { | |
| const { data } = await supabase.auth.getSession(); | |
| const accessToken = data.session?.access_token?.trim(); | |
| if (!accessToken) { | |
| return {}; | |
| } | |
| return { Authorization: `Bearer ${accessToken}` }; | |
| } catch { | |
| return {}; | |
| } | |
| } | |
| async function fetchWithTimeout(input: RequestInfo | URL, init: RequestInit = {}, timeoutMs = API_REQUEST_TIMEOUT_MS): Promise<Response> { | |
| const controller = new AbortController(); | |
| const timeout = window.setTimeout(() => controller.abort(), timeoutMs); | |
| try { | |
| return await fetch(input, { | |
| ...init, | |
| signal: controller.signal, | |
| }); | |
| } finally { | |
| window.clearTimeout(timeout); | |
| } | |
| } | |
| // No withFallback wrappers — all errors propagate to the UI for retry | |
| async function parseResponse<T>(response: Response): Promise<T> { | |
| const raw = await response.text(); | |
| let payload: ApiEnvelope<T> | null = null; | |
| if (raw) { | |
| try { | |
| payload = JSON.parse(raw) as ApiEnvelope<T>; | |
| } catch { | |
| payload = null; | |
| } | |
| } | |
| if (!response.ok) { | |
| if (payload?.error) { | |
| throw new Error(payload.error); | |
| } | |
| if (!payload) { | |
| throw new Error( | |
| `API ${response.status} returned non-JSON at ${response.url}. Run npm run dev:full or confirm VITE_API_BASE_URL.` | |
| ); | |
| } | |
| throw new Error(`API request failed with status ${response.status}`); | |
| } | |
| if (!payload || !payload.success || payload.data === undefined) { | |
| throw new Error('API returned an unexpected response shape'); | |
| } | |
| return payload.data; | |
| } | |
| async function postJson<T>(path: string, body: unknown): Promise<T> { | |
| let response: Response; | |
| try { | |
| const authorizationHeader = await getAuthorizationHeader(); | |
| response = await fetchWithTimeout(buildUrl(path), { | |
| method: 'POST', | |
| headers: { 'Content-Type': 'application/json', ...authorizationHeader }, | |
| body: JSON.stringify(body), | |
| }); | |
| } catch (error) { | |
| throw new Error(getNetworkErrorMessage(error)); | |
| } | |
| return parseResponse<T>(response); | |
| } | |
| async function getJson<T>(path: string): Promise<T> { | |
| let response: Response; | |
| try { | |
| const authorizationHeader = await getAuthorizationHeader(); | |
| response = await fetchWithTimeout(buildUrl(path), { | |
| method: 'GET', | |
| headers: { 'Content-Type': 'application/json', ...authorizationHeader }, | |
| }); | |
| } catch (error) { | |
| throw new Error(getNetworkErrorMessage(error)); | |
| } | |
| return parseResponse<T>(response); | |
| } | |
| let clientCachedFreeCourses: FreeCourseItem[] | null = null; | |
| export const getcertV2API = { | |
| generateCourse(skill: string): Promise<GeneratedCourseV2> { | |
| return postJson<GeneratedCourseV2>('/api/v2/course', { skill }); | |
| }, | |
| generateAssessment(skill: string, moduleTitles: string[], context?: AssessmentGenerationContextV2): Promise<AssessmentPackV2> { | |
| return postJson<AssessmentPackV2>('/api/v2/assessment', { | |
| mode: 'generate', | |
| skill, | |
| moduleTitles, | |
| courseSummary: context?.courseSummary, | |
| moduleContext: context?.modules, | |
| }); | |
| }, | |
| gradeAssessment(pack: AssessmentPackV2, submission: AssessmentSubmissionV2): Promise<AssessmentResultV2> { | |
| return postJson<AssessmentResultV2>('/api/v2/assessment', { | |
| mode: 'grade', | |
| pack, | |
| submission, | |
| }); | |
| }, | |
| generateProject(skill: string): Promise<GeneratedProjectV2> { | |
| return postJson<GeneratedProjectV2>('/api/v2/project', { skill }); | |
| }, | |
| validateGitHub(repoUrl: string): Promise<GitHubValidationReportV2> { | |
| return postJson<GitHubValidationReportV2>('/api/v2/github-validate', { repoUrl }); | |
| }, | |
| generateProjectQuestions( | |
| skill: string, | |
| url: string, | |
| retryCount = 0, | |
| isDesignProject = false | |
| ): Promise<{ | |
| questions: SmartQuestionV2[]; | |
| metadata: GitHubValidationReportV2['metadata']; | |
| validationSummary: { | |
| overallPassed: boolean; | |
| commitPassed: boolean; | |
| readmePassed: boolean; | |
| }; | |
| }> { | |
| return postJson('/api/v2/project-questions', { | |
| skill, | |
| repoUrl: isDesignProject ? undefined : url, | |
| portfolioUrl: isDesignProject ? url : undefined, | |
| retryCount, | |
| isDesignProject, | |
| }); | |
| }, | |
| evaluateProject(payload: { | |
| skill: string; | |
| repoUrl?: string; | |
| projectType: 'web' | 'python' | 'data' | 'design'; | |
| liveDemoUrl?: string; | |
| portfolioUrl?: string; | |
| notebookUrl?: string; | |
| questions: SmartQuestionV2[]; | |
| answers: Array<{ questionId: string; answer: string }>; | |
| }): Promise<ProjectEvaluationV2> { | |
| return postJson<ProjectEvaluationV2>('/api/v2/project-evaluate', payload); | |
| }, | |
| submitPaymentRequest(payload: { | |
| userId: string; | |
| txnId?: string; | |
| skill: string; | |
| projectTitle: string; | |
| githubUrl?: string; | |
| proofUrl: string; | |
| finalScore: number; | |
| scoreBreakdown?: ProjectEvaluationV2['scoreBreakdown']; | |
| validationSummary?: ProjectEvaluationV2['validationSummary']; | |
| projectType?: 'web' | 'python' | 'data' | 'design'; | |
| commitCount?: number; | |
| liveDemoUrl?: string; | |
| paymentRequestId?: string; | |
| track?: CertificationTrack; | |
| email?: string; | |
| phone?: string; | |
| promoCode?: string; | |
| amountInr?: number; | |
| }): Promise<PaymentRequestResponseV2> { | |
| return postJson<PaymentRequestResponseV2>('/api/v2/payment-submit', payload); | |
| }, | |
| getPaymentStatus( | |
| userId: string, | |
| paymentRequestId?: string, | |
| txnId?: string, | |
| skill?: string, | |
| projectTitle?: string, | |
| track?: string, | |
| ): Promise<PaymentRequestResponseV2> { | |
| const query = new URLSearchParams({ userId }); | |
| if (paymentRequestId) { | |
| query.set('paymentRequestId', paymentRequestId); | |
| } | |
| if (txnId) { | |
| query.set('txnId', txnId); | |
| } | |
| if (skill) { | |
| query.set('skill', skill); | |
| } | |
| if (projectTitle) { | |
| query.set('projectTitle', projectTitle); | |
| } | |
| if (track) { | |
| query.set('track', track); | |
| } | |
| return getJson<PaymentRequestResponseV2>( | |
| `/api/v2/payment-status?${query.toString()}` | |
| ); | |
| }, | |
| certify(payload: { | |
| userId: string; | |
| name: string; | |
| email: string; | |
| skill: string; | |
| projectTitle: string; | |
| githubUrl?: string; | |
| proofUrl: string; | |
| finalScore: number; | |
| scoreBreakdown?: ProjectEvaluationV2['scoreBreakdown']; | |
| validationSummary?: ProjectEvaluationV2['validationSummary']; | |
| projectType?: 'web' | 'python' | 'data' | 'design'; | |
| commitCount?: number; | |
| liveDemoUrl?: string; | |
| paymentRequestId?: string; | |
| txnId?: string; | |
| track?: CertificationTrack; | |
| }): Promise<IssuedCertificateV2> { | |
| return postJson<IssuedCertificateV2>('/api/v2/certify', payload); | |
| }, | |
| getCertificate(certificateId: string): Promise<CertificateDetailsV2> { | |
| return getJson<CertificateDetailsV2>(`/api/v2/certificate/${encodeURIComponent(certificateId)}`); | |
| }, | |
| getPublicProfile(userId: string): Promise<PublicProfileV2> { | |
| return getJson<PublicProfileV2>(`/api/v2/profile/${encodeURIComponent(userId)}`); | |
| }, | |
| getHealth(): Promise<HealthStatusV2> { | |
| return getJson<HealthStatusV2>('/api/v2/health'); | |
| }, | |
| async getFreeCourses(): Promise<FreeCourseItem[]> { | |
| if (clientCachedFreeCourses && clientCachedFreeCourses.length > 0) { | |
| return clientCachedFreeCourses; | |
| } | |
| // 1. Direct Supabase query (Lightning fast: 30-50ms directly from Supabase, zero server cold-start) | |
| try { | |
| const { data, error } = await supabase | |
| .from('free_courses') | |
| .select('*') | |
| .eq('is_active', true) | |
| .order('display_order', { ascending: true }); | |
| if (!error && data && data.length > 0) { | |
| const items = data.map((row: any) => { | |
| const videoId = row.youtube_video_id || 'kqtD5dpn9C8'; | |
| const maxStudents = typeof row.max_students === 'number' && row.max_students > 0 ? row.max_students : null; | |
| const certifiedCount = typeof row.certified_students_count === 'number' ? row.certified_students_count : 0; | |
| return { | |
| id: row.id, | |
| courseId: row.course_id, | |
| title: row.title, | |
| skill: row.skill, | |
| description: row.description || '', | |
| category: row.category || 'Programming', | |
| level: row.level || 'Beginner', | |
| durationMinutes: row.duration_minutes || 30, | |
| maxStudents, | |
| certifiedStudentsCount: certifiedCount, | |
| isSoldOut: Boolean(maxStudents !== null && certifiedCount >= maxStudents), | |
| remainingSlots: maxStudents !== null ? Math.max(0, maxStudents - certifiedCount) : null, | |
| youtubeUrl: row.youtube_url || `https://www.youtube.com/watch?v=${videoId}`, | |
| youtubeVideoId: videoId, | |
| channelTitle: row.channel_title || 'Programming with Mosh', | |
| thumbnailUrl: row.thumbnail_url || `https://img.youtube.com/vi/${videoId}/hqdefault.jpg`, | |
| embedUrl: `https://www.youtube-nocookie.com/embed/${videoId}?rel=0`, | |
| isActive: Boolean(row.is_active ?? true), | |
| displayOrder: row.display_order ?? 0, | |
| keyTakeaways: Array.isArray(row.key_takeaways) ? row.key_takeaways : [], | |
| quizQuestions: Array.isArray(row.quiz_questions) ? row.quiz_questions : [], | |
| createdAt: row.created_at, | |
| updatedAt: row.updated_at, | |
| }; | |
| }); | |
| clientCachedFreeCourses = items; | |
| return items; | |
| } | |
| } catch { | |
| // Supabase query error or table not yet migrated | |
| } | |
| // 2. Fast API probe with 2000ms timeout (never hang for 120s on sleeping containers) | |
| try { | |
| const controller = new AbortController(); | |
| const timeout = setTimeout(() => controller.abort(), 2000); | |
| const url = buildUrl('/api/v2/free-courses'); | |
| const response = await fetch(url, { signal: controller.signal }); | |
| clearTimeout(timeout); | |
| if (response.ok) { | |
| const payload = await response.json(); | |
| if (payload?.success && Array.isArray(payload.data?.courses) && payload.data.courses.length > 0) { | |
| clientCachedFreeCourses = payload.data.courses; | |
| return payload.data.courses; | |
| } | |
| } | |
| } catch { | |
| // Backend cold starting or unreachable | |
| } | |
| // 3. Instant local fallback (0ms) | |
| clientCachedFreeCourses = DEFAULT_FREE_COURSES; | |
| return DEFAULT_FREE_COURSES; | |
| }, | |
| async updateFreeCourseProgress(payload: { | |
| courseId: string; | |
| courseTitle: string; | |
| progressPercentage?: number; | |
| currentStep?: string; | |
| status?: string; | |
| score?: number; | |
| }): Promise<{ success: boolean }> { | |
| try { | |
| return await postJson<{ success: boolean }>('/api/v2/free-courses/progress', payload); | |
| } catch { | |
| return { success: false }; | |
| } | |
| }, | |
| completeFreeCourse(payload: FreeCourseCompletionPayload): Promise<IssuedCertificateV2> { | |
| return postJson<IssuedCertificateV2>('/api/v2/free-courses/complete', payload); | |
| }, | |
| // ─── GetCert YT ("Certify Your Learning from YouTube") ───────────────────── | |
| analyzeYouTubeCourse(url: string): Promise<YtAnalyzeResponse> { | |
| return postJson<YtAnalyzeResponse>('/api/v2/yt/analyze', { url }); | |
| }, | |
| startYtAssessment(snapshotId: string): Promise<YtAssessmentStartResponse> { | |
| return postJson<YtAssessmentStartResponse>('/api/v2/yt/assessment/start', { snapshotId }); | |
| }, | |
| submitYtAssessment(payload: { | |
| snapshotId: string; | |
| attemptId: string; | |
| answers: Record<string, number>; | |
| }): Promise<YtAssessmentGradeResult> { | |
| return postJson<YtAssessmentGradeResult>('/api/v2/yt/assessment/submit', payload); | |
| }, | |
| checkoutYtCertification(payload: { | |
| snapshotId: string; | |
| score: number; | |
| email?: string; | |
| }): Promise<{ | |
| paywallEnabled: boolean; | |
| amountInr: number; | |
| checkoutUrl: string; | |
| checkoutId: string; | |
| paymentSessionId: string; | |
| track: string; | |
| message: string; | |
| }> { | |
| return postJson('/api/v2/yt/checkout', payload); | |
| }, | |
| certifyYtCourse(payload: { | |
| userId: string; | |
| name: string; | |
| email: string; | |
| skill: string; | |
| projectTitle: string; | |
| finalScore: number; | |
| paymentRequestId?: string; | |
| txnId?: string; | |
| track: 'ytcert'; | |
| extraMetadata?: Record<string, any>; | |
| }): Promise<IssuedCertificateV2> { | |
| return postJson<IssuedCertificateV2>('/api/v2/certify', payload); | |
| }, | |
| }; | |