fix(cert): auto-issue certificate on payment confirmation & sync course to 100% certified

api/index.ts

@@ -56,6 +56,7 @@ import {
   assertApprovedPaymentForCertificate,
   markPaymentRequestCertificateIssued,
   reviewPaymentRequest,
+  processApprovedPaymentAndIssueCertificate,
 } from './v2/_services/paymentApprovalSystem.js';
 import { getOrder, createOrder, isOrderPaidOnCashfree, getOrderPayments } from './v2/_services/cashfreeService.js';
 import { issueCertificate } from './v2/_services/certificationSystem.js';
@@ -831,23 +832,20 @@ async function handlePaymentStatus(req: VercelRequest, res: VercelResponse): Pro
       }
     }
 
-    let alreadyIssuedCertificate = false;
-    if (request.status === 'paid' && !request.certificateIssued && request.id) {
-      const supabase = getSupabaseClientForRequest(authToken);
-      const { data } = await supabase
-        .from('certificates')
-        .select('id')
-        .eq('metadata->>payment_request_id', request.id)
-        .maybeSingle();
-      alreadyIssuedCertificate = Boolean(data);
+    let certificatePayload = null;
+    if (request.status === 'paid' && request.id) {
+      certificatePayload = await processApprovedPaymentAndIssueCertificate(request.id);
+      if (certificatePayload) {
+        request.certificateIssued = true;
+      }
     }
 
     ok(res, {
       paywallEnabled: true,
       amountInr: getCertificateFeeInr(request.track as CertificationTrack),
       request,
-      canIssueCertificate:
-        request.status === 'paid' && !request.certificateIssued && !alreadyIssuedCertificate,
+      certificate: certificatePayload,
+      canIssueCertificate: false,
     });
   } catch (error) {
     fail(res, 500, 'Failed to fetch payment status', error instanceof Error ? error.message : error);
@@ -1262,8 +1260,9 @@ async function handleWebhookCashfree(req: VercelRequest, res: VercelResponse): P
       String(body.data?.payment?.payment_status || '').toUpperCase() === 'USER_DROPPED';
 
     if (isSuccess && requestRow.status !== 'paid') {
-      logger.info(`[Cashfree Webhook] Marking payment request ${orderId} as PAID.`, ctx);
+      logger.info(`[Cashfree Webhook] Marking payment request ${orderId} as PAID and auto-issuing certificate.`, ctx);
       await updatePaymentRequestStatus(orderId, 'paid', null);
+      await processApprovedPaymentAndIssueCertificate(orderId);
     } else if (isFailed && requestRow.status === 'pending') {
       logger.info(`[Cashfree Webhook] Marking payment request ${orderId} as REJECTED.`, ctx);
       await updatePaymentRequestStatus(orderId, 'rejected', null);

api/v2/_services/certificationSystem.ts

@@ -1,5 +1,5 @@
 import type { CertificatePayload, CertificationTrack, ScoreBreakdown, ValidationSummary } from '../_types.js';
-import { getSupabaseClientForRequest } from '../_shared/supabaseAdmin.js';
+import { getSupabaseAdmin, getSupabaseClientForRequest } from '../_shared/supabaseAdmin.js';
 
 function makeCertificateId(skill: string, track: CertificationTrack = 'verifiedcert'): string {
   const date = new Date();
@@ -32,7 +32,8 @@ export async function issueCertificate(input: {
   authToken?: string | null;
   track?: CertificationTrack;
 }): Promise<CertificatePayload> {
-  const supabase = getSupabaseClientForRequest(input.authToken);
+  const serviceRoleKey = process.env.SUPABASE_SERVICE_ROLE_KEY;
+  const supabase = (!input.authToken && serviceRoleKey) ? getSupabaseAdmin() : getSupabaseClientForRequest(input.authToken);
   const certTrack = input.track || 'verifiedcert';
 
   if (input.paymentRequestId) {

api/v2/_services/paymentApprovalSystem.ts

@@ -1,5 +1,7 @@
 import { getSupabaseAdmin, getSupabaseClientForRequest } from '../_shared/supabaseAdmin.js';
 import { isOrderPaidOnCashfree } from './cashfreeService.js';
+import { issueCertificate } from './certificationSystem.js';
+import { sendCertificateIssuedEmail } from './emailService.js';
 import { backendLogger as logger } from '../_shared/backendLogger.js';
 import type {
   ApprovedPaymentContext,
@@ -116,7 +118,8 @@ async function findCertificateByPaymentRequestId(
 }
 
 export async function submitPaymentRequest(input: PaymentRequestCreateInput & { id?: string }, authToken?: string | null): Promise<PaymentRequest> {
-  const supabase = getSupabaseClientForRequest(authToken);
+  const serviceRoleKey = process.env.SUPABASE_SERVICE_ROLE_KEY;
+  const supabase = (!authToken && serviceRoleKey) ? getSupabaseAdmin() : getSupabaseClientForRequest(authToken);
 
   const { data, error } = await supabase
     .from(PAYMENT_REQUESTS_TABLE)
@@ -407,5 +410,191 @@ export async function updatePaymentRequestStatus(
     throw new Error(`Failed to update payment request status: ${error?.message || 'unknown error'}${rlsHint}`);
   }
 
+  if (status === 'paid') {
+    // Automatically issue certificate and set my_courses progress to 100%
+    void processApprovedPaymentAndIssueCertificate(requestId).catch((err) => {
+      logger.error('[Auto-Issuance Trigger Failed in updatePaymentRequestStatus]', err);
+    });
+  }
+
   return mapPaymentRequest(data);
 }
+
+// Concurrency mutex to prevent duplicate simultaneous issuances for the same payment request
+const inFlightIssuancesByOrderId = new Map<string, Promise<CertificatePayload | null>>();
+
+export async function syncCourseProgressToCertified(
+  userId: string,
+  courseName: string,
+  track: string,
+  issuedAt: string,
+  score: number = 100
+): Promise<void> {
+  const supabase = getSupabaseAdmin();
+  const nowIso = issuedAt || new Date().toISOString();
+
+  try {
+    // 1. Upsert into my_courses
+    const { error: myCourseErr } = await supabase
+      .from('my_courses')
+      .upsert({
+        user_id: userId,
+        course_name: courseName,
+        status: 'certified',
+        current_step: 'certified',
+        progress_percentage: 100,
+        assessment_score: score,
+        certification_track: track,
+        completed_at: nowIso,
+        last_activity: nowIso,
+        updated_at: nowIso,
+      }, { onConflict: 'user_id,course_name' });
+
+    if (myCourseErr) {
+      logger.warn('[Auto-Issuance] my_courses upsert error:', myCourseErr);
+    }
+
+    // 2. Update course_sessions
+    await supabase
+      .from('course_sessions')
+      .update({
+        current_step: 'certified',
+        progress_percentage: 100,
+        updated_at: nowIso,
+      })
+      .eq('user_id', userId)
+      .eq('course_name', courseName);
+  } catch (syncErr) {
+    logger.warn(`[Auto-Issuance] Could not sync course progress to certified for ${courseName}:`, syncErr);
+  }
+}
+
+export async function processApprovedPaymentAndIssueCertificate(
+  paymentRequestId: string
+): Promise<CertificatePayload | null> {
+  const existingPromise = inFlightIssuancesByOrderId.get(paymentRequestId);
+  if (existingPromise) {
+    return existingPromise;
+  }
+
+  const executionPromise = (async () => {
+    const supabase = getSupabaseAdmin();
+
+    // 1. Fetch the payment request
+    const { data: request, error: reqErr } = await supabase
+      .from(PAYMENT_REQUESTS_TABLE)
+      .select('*')
+      .eq('id', paymentRequestId)
+      .maybeSingle();
+
+    if (reqErr || !request) {
+      logger.warn(`[Auto-Issuance] Payment request not found for ID: ${paymentRequestId}`, reqErr);
+      return null;
+    }
+
+    if (request.status !== 'paid') {
+      logger.warn(`[Auto-Issuance] Payment request ${paymentRequestId} is not marked paid (status: ${request.status})`);
+      return null;
+    }
+
+    const track = (request.track || 'quickcert') as CertificationTrack;
+
+    // 2. Check if certificate is already issued
+    const existingCert = await findCertificateByPaymentRequestId(request.id, null);
+    if (existingCert) {
+      if (!request.certificate_issued) {
+        await markPaymentRequestCertificateIssued(request.id, null);
+      }
+      await syncCourseProgressToCertified(request.user_id, request.skill, track, existingCert.issuedAt);
+      return existingCert;
+    }
+
+    // 3. Resolve student name & email safely from public.users & Supabase auth
+    let studentName = '';
+    let studentEmail = '';
+    try {
+      const { data: dbUser } = await supabase
+        .from('users')
+        .select('full_name, username, email')
+        .eq('id', request.user_id)
+        .maybeSingle();
+
+      const { data: authUserData } = await supabase.auth.admin.getUserById(request.user_id);
+
+      studentEmail = dbUser?.email || authUserData?.user?.email || '';
+      studentName =
+        dbUser?.full_name ||
+        dbUser?.username ||
+        authUserData?.user?.user_metadata?.full_name ||
+        authUserData?.user?.user_metadata?.name ||
+        (studentEmail ? studentEmail.split('@')[0] : '') ||
+        'GetCert Student';
+    } catch (userErr) {
+      logger.warn(`[Auto-Issuance] Failed to resolve user info for ${request.user_id}:`, userErr);
+      studentName = 'GetCert Student';
+    }
+
+    // 4. Resolve assessment score from course_sessions
+    let score = 90;
+    try {
+      const { data: sessionData } = await supabase
+        .from('course_sessions')
+        .select('flow_state')
+        .eq('user_id', request.user_id)
+        .eq('course_name', request.skill)
+        .order('updated_at', { ascending: false })
+        .limit(1)
+        .maybeSingle();
+
+      if (sessionData?.flow_state?.assessmentScore) {
+        score = sessionData.flow_state.assessmentScore;
+      }
+    } catch {
+      // Default to 90
+    }
+
+    // 5. Issue official certificate
+    const issuedCertificate = await issueCertificate({
+      userId: request.user_id,
+      name: studentName,
+      email: studentEmail,
+      skill: request.skill,
+      projectTitle: request.project_title || `${request.skill} Quick Certification`,
+      githubUrl: '',
+      proofUrl: '',
+      finalScore: score,
+      paymentRequestId: request.id,
+      paymentTxnId: request.txn_id,
+      track,
+      authToken: null,
+    });
+
+    // 6. Mark payment request as certificate issued
+    await markPaymentRequestCertificateIssued(request.id, null);
+
+    // 7. Update my_courses and course_sessions to 100% and certified
+    await syncCourseProgressToCertified(request.user_id, request.skill, track, issuedCertificate.issuedAt, score);
+
+    // 8. Send notification email asynchronously
+    if (studentEmail) {
+      sendCertificateIssuedEmail({
+        to: studentEmail,
+        name: studentName,
+        certificate: issuedCertificate,
+      }).catch((emailErr) => {
+        logger.warn('[Auto-Issuance] Email dispatch notice:', emailErr);
+      });
+    }
+
+    logger.info(`[Auto-Issuance] Successfully issued certificate ${issuedCertificate.certificateId} and set my_courses progress to 100% for user ${request.user_id}`);
+    return issuedCertificate;
+  })();
+
+  inFlightIssuancesByOrderId.set(paymentRequestId, executionPromise);
+
+  try {
+    return await executionPromise;
+  } finally {
+    inFlightIssuancesByOrderId.delete(paymentRequestId);
+  }
+}

public/llms-full.txt

@@ -1,6 +1,6 @@
 # GetCert — full site reference
 
-Generated 2026-10-11 from https://getcert.eu.cc
+Generated 2026-10-12 from https://getcert.eu.cc
 
 ## Summary
 

public/llms.txt

@@ -2,7 +2,7 @@
 
 > GetCert is a free online learning platform. Learners take free online courses, pass an assessment, and receive a certificate with a unique certificate ID that anyone can verify publicly at https://getcert.eu.cc/verify — no account required.
 
-Last updated: 2026-10-11
+Last updated: 2026-10-12
 
 ## What GetCert is
 

public/sitemap.xml

@@ -2,67 +2,67 @@
 <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
   <url>
     <loc>https://getcert.eu.cc/</loc>
-    <lastmod>2026-10-11</lastmod>
+    <lastmod>2026-10-12</lastmod>
     <changefreq>weekly</changefreq>
     <priority>1.0</priority>
   </url>
   <url>
     <loc>https://getcert.eu.cc/courses</loc>
-    <lastmod>2026-10-11</lastmod>
+    <lastmod>2026-10-12</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.9</priority>
   </url>
   <url>
     <loc>https://getcert.eu.cc/learn</loc>
-    <lastmod>2026-10-11</lastmod>
+    <lastmod>2026-10-12</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.8</priority>
   </url>
   <url>
     <loc>https://getcert.eu.cc/verify</loc>
-    <lastmod>2026-10-11</lastmod>
+    <lastmod>2026-10-12</lastmod>
     <changefreq>monthly</changefreq>
     <priority>0.7</priority>
   </url>
   <url>
     <loc>https://getcert.eu.cc/yt</loc>
-    <lastmod>2026-10-11</lastmod>
+    <lastmod>2026-10-12</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.7</priority>
   </url>
   <url>
     <loc>https://getcert.eu.cc/about</loc>
-    <lastmod>2026-10-11</lastmod>
+    <lastmod>2026-10-12</lastmod>
     <changefreq>monthly</changefreq>
     <priority>0.6</priority>
   </url>
   <url>
     <loc>https://getcert.eu.cc/contact</loc>
-    <lastmod>2026-10-11</lastmod>
+    <lastmod>2026-10-12</lastmod>
     <changefreq>yearly</changefreq>
     <priority>0.5</priority>
   </url>
   <url>
     <loc>https://getcert.eu.cc/honor-code</loc>
-    <lastmod>2026-10-11</lastmod>
+    <lastmod>2026-10-12</lastmod>
     <changefreq>yearly</changefreq>
     <priority>0.4</priority>
   </url>
   <url>
     <loc>https://getcert.eu.cc/terms</loc>
-    <lastmod>2026-10-11</lastmod>
+    <lastmod>2026-10-12</lastmod>
     <changefreq>yearly</changefreq>
     <priority>0.3</priority>
   </url>
   <url>
     <loc>https://getcert.eu.cc/privacy</loc>
-    <lastmod>2026-10-11</lastmod>
+    <lastmod>2026-10-12</lastmod>
     <changefreq>yearly</changefreq>
     <priority>0.3</priority>
   </url>
   <url>
     <loc>https://getcert.eu.cc/refund</loc>
-    <lastmod>2026-10-11</lastmod>
+    <lastmod>2026-10-12</lastmod>
     <changefreq>yearly</changefreq>
     <priority>0.3</priority>
   </url>
@@ -92,13 +92,13 @@
   </url>
   <url>
     <loc>https://getcert.eu.cc/free-course/javascript-crash-course-for-beginners-68e3</loc>
-    <lastmod>2026-10-11</lastmod>
+    <lastmod>2026-10-12</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.8</priority>
   </url>
   <url>
     <loc>https://getcert.eu.cc/free-course/python-basics-30m</loc>
-    <lastmod>2026-10-11</lastmod>
+    <lastmod>2026-10-12</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.8</priority>
   </url>

src/components/MyCourses.tsx

@@ -260,7 +260,13 @@ export function MyCourses({ userId }: MyCoursesProps) {
                   <div className="grid grid-cols-2 sm:grid-cols-4 gap-4 text-xs text-slate-600">
                     <div>
                       <span className="font-semibold text-slate-400 block mb-0.5">Current Stage</span>
-                      <span className="inline-block px-2.5 py-0.5 bg-blue-50 text-blue-800 font-semibold rounded-md border border-blue-200/60">{course.current_step}</span>
+                      <span className={`inline-block px-2.5 py-0.5 font-semibold rounded-md border ${
+                        course.status === 'certified' 
+                          ? 'bg-emerald-50 text-emerald-800 border-emerald-200/60'
+                          : 'bg-blue-50 text-blue-800 border-blue-200/60'
+                      }`}>
+                        {course.status === 'certified' ? 'Certified' : course.current_step}
+                      </span>
                     </div>
                     {course.assessment_score && (
                       <div>
@@ -283,24 +289,40 @@ export function MyCourses({ userId }: MyCoursesProps) {
                 <div className="w-full md:w-48 space-y-2">
                   <div className="flex justify-between items-center text-xs font-semibold">
                     <span className="text-slate-500">Curriculum Progress</span>
-                    <span className="text-[#132F50] font-bold">{course.progress_percentage}%</span>
+                    <span className={course.status === 'certified' || course.progress_percentage === 100 ? "text-emerald-700 font-bold" : "text-[#132F50] font-bold"}>
+                      {course.status === 'certified' ? 100 : course.progress_percentage}%
+                    </span>
                   </div>
                   <div className="w-full h-2.5 bg-slate-100 rounded-full overflow-hidden">
                     <div
-                      className="h-full bg-[#132F50] rounded-full transition-all duration-300"
-                      style={{ width: `${Math.max(5, course.progress_percentage)}%` }}
+                      className={`h-full rounded-full transition-all duration-300 ${
+                        course.status === 'certified' || course.progress_percentage === 100
+                          ? 'bg-emerald-600'
+                          : 'bg-[#132F50]'
+                      }`}
+                      style={{ width: `${course.status === 'certified' ? 100 : Math.max(5, course.progress_percentage)}%` }}
                     />
                   </div>
                 </div>
 
                 {/* Course Actions */}
                 <div className="flex items-center gap-2.5">
-                  <button
-                    onClick={() => handleContinueCourse(course)}
-                    className="px-4 py-2 bg-[#132F50] hover:bg-blue-900 text-white rounded-xl text-xs font-bold tracking-tight shadow-xs transition-colors whitespace-nowrap cursor-pointer"
-                  >
-                    Resume Study →
-                  </button>
+                  {course.status === 'certified' || course.progress_percentage === 100 ? (
+                    <button
+                      onClick={() => navigate('/my-certificates')}
+                      className="px-4 py-2 bg-emerald-600 hover:bg-emerald-700 text-white rounded-xl text-xs font-bold tracking-tight shadow-xs transition-colors whitespace-nowrap cursor-pointer flex items-center gap-1.5"
+                    >
+                      <span>View Certificate</span>
+                      <span>🎓</span>
+                    </button>
+                  ) : (
+                    <button
+                      onClick={() => handleContinueCourse(course)}
+                      className="px-4 py-2 bg-[#132F50] hover:bg-blue-900 text-white rounded-xl text-xs font-bold tracking-tight shadow-xs transition-colors whitespace-nowrap cursor-pointer"
+                    >
+                      Resume Study →
+                    </button>
+                  )}
                   
                   <button
                     onClick={() => handleRestartCourse(course.course_name)}

src/components/certification-flow/quick-cert/QuickCertPayment.tsx

@@ -50,6 +50,9 @@ export function QuickCertPayment({
 
   const handleIssuedCertificate = useCallback((issued: IssuedCertificateV2) => {
     setCertificate(issued);
+    try {
+      localStorage.removeItem('getcert_active_flow');
+    } catch {}
     onCertified(issued);
   }, [onCertified]);
 
@@ -113,6 +116,12 @@ export function QuickCertPayment({
       );
       setPaywallEnabled(response.paywallEnabled);
 
+      if (response.certificate) {
+        handleIssuedCertificate(response.certificate);
+        setPaymentNote('Certificate issued successfully.');
+        return response.request;
+      }
+
       if (!response.request) {
         return null;
       }
@@ -134,7 +143,7 @@ export function QuickCertPayment({
     } finally {
       if (!silent) setLoadingAction(null);
     }
-  }, [courseName, handleIssueCertificate, userId]);
+  }, [courseName, handleIssueCertificate, handleIssuedCertificate, userId]);
 
   const handleProceedToCheckout = async () => {
     setError(null);

src/lib/courseSessionPersistence.ts

@@ -397,19 +397,20 @@ export async function updateMyCourse(
  * Get all courses for a user (for My Courses page)
  * Cross-references both my_courses and certificates table to guarantee zero lost progress.
  */
-export async function getMyCourses(userId: string): Promise<{ courses: MyCourse[]; error?: string }> {
+export async function getMyCourses(userId: string, customClient?: any): Promise<{ courses: MyCourse[]; error?: string }> {
   try {
     logger.log(` Loading My Courses for user ${userId}`);
+    const client = customClient || supabase;
 
     // Query 1: Courses from my_courses table
-    const coursesQuery = supabase
+    const coursesQuery = client
       .from('my_courses')
       .select('*')
       .eq('user_id', userId)
       .order('last_activity', { ascending: false });
 
     // Query 2: Earned certificates from certificates table
-    const certsQuery = supabase
+    const certsQuery = client
       .from('certificates')
       .select('id, user_id, topic, project_title, issued_at, metadata')
       .eq('user_id', userId)
@@ -420,6 +421,9 @@ export async function getMyCourses(userId: string): Promise<{ courses: MyCourse[
     if (coursesRes.error) {
       logger.error(' Error loading My Courses:', coursesRes.error);
     }
+    if (certsRes.error) {
+      logger.error(' Error loading Certificates:', certsRes.error);
+    }
 
     const dbCourses: MyCourse[] = coursesRes.data || [];
     const dbCerts = certsRes.data || [];
@@ -436,30 +440,59 @@ export async function getMyCourses(userId: string): Promise<{ courses: MyCourse[
       const normalizedName = courseName.toLowerCase().trim();
       const topicNormalized = (cert.topic || '').toLowerCase().trim();
 
-      const alreadyExists = Array.from(existingCourseNames).some(
-        (existing) =>
-          existing === normalizedName ||
-          (topicNormalized && (existing.includes(topicNormalized) || topicNormalized.includes(existing)))
-      );
-
-      if (!alreadyExists) {
-        let track: 'quickcert' | 'verifiedcert' | 'free_completion' = 'quickcert';
-        if (
-          meta.certification_track === 'free_completion' ||
-          meta.track === 'free_completion' ||
-          meta.free_course ||
-          meta.completion_type === 'free_starter_course' ||
-          String(meta.certificate_id || cert.id).startsWith('FC')
-        ) {
-          track = 'free_completion';
-        } else if (
-          meta.certification_track === 'verifiedcert' ||
-          meta.track === 'verifiedcert' ||
-          String(meta.certificate_id || cert.id).startsWith('VC')
-        ) {
-          track = 'verifiedcert';
-        }
+      // Check if an existing enrolled course in my_courses matches this certificate
+      const matchingCourse = dbCourses.find((c) => {
+        const cNorm = c.course_name.toLowerCase().trim();
+        return (
+          cNorm === normalizedName ||
+          (topicNormalized && (cNorm.includes(topicNormalized) || topicNormalized.includes(cNorm)))
+        );
+      });
 
+      let track: 'quickcert' | 'verifiedcert' | 'free_completion' = 'quickcert';
+      if (
+        meta.certification_track === 'free_completion' ||
+        meta.track === 'free_completion' ||
+        meta.free_course ||
+        meta.completion_type === 'free_starter_course' ||
+        String(meta.certificate_id || cert.id).startsWith('FC')
+      ) {
+        track = 'free_completion';
+      } else if (
+        meta.certification_track === 'verifiedcert' ||
+        meta.track === 'verifiedcert' ||
+        String(meta.certificate_id || cert.id).startsWith('VC')
+      ) {
+        track = 'verifiedcert';
+      }
+
+      if (matchingCourse) {
+        // Upgrade existing course to 100% certified immediately
+        if (matchingCourse.status !== 'certified' || matchingCourse.progress_percentage !== 100) {
+          matchingCourse.status = 'certified';
+          matchingCourse.current_step = 'certified';
+          matchingCourse.progress_percentage = 100;
+          matchingCourse.completed_at = cert.issued_at || matchingCourse.completed_at || new Date().toISOString();
+          matchingCourse.last_activity = cert.issued_at || matchingCourse.last_activity || new Date().toISOString();
+          if (meta.final_score) {
+            matchingCourse.assessment_score = meta.final_score;
+          }
+
+          // Asynchronously self-heal database row
+          void client
+            .from('my_courses')
+            .update({
+              status: 'certified',
+              current_step: 'certified',
+              progress_percentage: 100,
+              completed_at: matchingCourse.completed_at,
+              last_activity: matchingCourse.last_activity,
+              updated_at: new Date().toISOString(),
+            })
+            .eq('id', matchingCourse.id);
+        }
+      } else {
+        // Synthesize course from certificate if no course row existed
         const synthetic: MyCourse = {
           id: cert.id,
           user_id: cert.user_id,
@@ -481,7 +514,7 @@ export async function getMyCourses(userId: string): Promise<{ courses: MyCourse[
         existingCourseNames.add(normalizedName);
 
         // Self-heal: backfill into my_courses table asynchronously
-        supabase
+        void client
           .from('my_courses')
           .upsert({
             user_id: cert.user_id,
@@ -493,9 +526,7 @@ export async function getMyCourses(userId: string): Promise<{ courses: MyCourse[
             certification_track: track,
             completed_at: cert.issued_at,
             last_activity: cert.issued_at,
-          }, { onConflict: 'user_id,course_name' })
-          .then(() => {})
-          .catch(() => {});
+          }, { onConflict: 'user_id,course_name' });
       }
     }
 

src/types/getcertV2.ts

@@ -283,6 +283,7 @@ export interface PaymentRequestResponseV2 {
   canIssueCertificate?: boolean;
   checkoutUrl?: string;
   checkoutId?: string;
+  certificate?: IssuedCertificateV2 | null;
 }
 
 export interface PublicProfileV2 {

src/utils/secureEnvironment.ts

@@ -29,11 +29,11 @@ class SecureEnvironment {
     }
 
     try {
-      const env = import.meta.env;
+      const env = (typeof import.meta !== 'undefined' && import.meta.env) ? import.meta.env : (process.env as any);
       
       // Check for required environment variables
-      const supabaseUrl = env.VITE_SUPABASE_URL;
-      const supabaseAnonKey = env.VITE_SUPABASE_ANON_KEY;
+      const supabaseUrl = env.VITE_SUPABASE_URL || env.SUPABASE_URL;
+      const supabaseAnonKey = env.VITE_SUPABASE_ANON_KEY || env.SUPABASE_ANON_KEY;
       
       if (!supabaseUrl) {
         throw new Error('VITE_SUPABASE_URL is required');

src/utils/secureLogger.ts

@@ -5,7 +5,7 @@
  * In production, all logging is disabled to prevent credential leaks.
  */
 
-const isDevelopment = import.meta.env.MODE === 'development';
+const isDevelopment = (typeof import.meta !== 'undefined' && import.meta.env?.MODE === 'development') || process.env.NODE_ENV === 'development';
 
 // List of sensitive patterns to redact
 const SENSITIVE_PATTERNS = [