Merge pull request #673 from T-kesh/main

ogazboiz · web-flow · commit 6bc358c89859 · 2026-04-05T15:20:50.000+01:00
Optimize getScoreBreakdown query to reduce database round-trips
diff --git a/backend/src/__tests__/scoreBreakdown.test.ts b/backend/src/__tests__/scoreBreakdown.test.ts
@@ -47,27 +47,29 @@ describe("GET /api/score/:userId/breakdown", () => {
   });
 
   it("should return a breakdown for a valid userId", async () => {
-    // Mock the chain of queries in the breakdown endpoint
+    // Mock the optimized single CTE query (returns all breakdown metrics)
     mockedQuery
-      .mockResolvedValueOnce({ rows: [{ current_score: 720 }] } as any) // Score
       .mockResolvedValueOnce({
         rows: [
           {
-            total_loans: "5",
-            repaid_count: "4",
-            defaulted_count: "0",
-            total_repaid: "5000",
+            current_score: 720,
+            total_loans: 5,
+            repaid_count: 4,
+            defaulted_count: 0,
+            total_repaid: 5000,
+            on_time_count: 3,
+            late_count: 1,
+            avg_repayment_ledgers: 17280,
           },
         ],
-      } as any) // Stats
-      .mockResolvedValueOnce({ rows: [{ on_time: "3", late: "1" }] } as any) // Timing
-      .mockResolvedValueOnce({ rows: [{ avg_ledgers: "17280" }] } as any) // Avg time
+      } as any) // Single CTE breakdown query
       .mockResolvedValueOnce({
-        rows: [{ on_time: true }, { on_time: true }, { on_time: true }],
-      } as any) // Streak
-      .mockResolvedValueOnce({
-        rows: [{ date: "2026-03-01", event: "LoanRepaid" }],
-      } as any); // History
+        rows: [
+          { event_type: "LoanRepaid", ledger_closed_at: "2026-03-01T10:00:00Z" },
+          { event_type: "LoanRepaid", ledger_closed_at: "2026-03-05T10:00:00Z" },
+          { event_type: "LoanRepaid", ledger_closed_at: "2026-03-10T10:00:00Z" },
+        ],
+      } as any); // History query
 
     const response = await request(app)
       .get("/api/score/user123/breakdown")
@@ -76,10 +78,17 @@ describe("GET /api/score/:userId/breakdown", () => {
     expect(response.status).toBe(200);
     expect(response.body.score).toBe(720);
     expect(response.body.breakdown.totalLoans).toBe(5);
+    expect(response.body.breakdown.repaidOnTime).toBe(3);
+    expect(response.body.breakdown.repaidLate).toBe(1);
+    expect(response.body.breakdown.defaulted).toBe(0);
+    expect(response.body.history).toHaveLength(3);
   });
 
   it("should return default values for a user with no history", async () => {
-    mockedQuery.mockResolvedValue({ rows: [] } as any);
+    // Mock empty breakdown and history queries
+    mockedQuery
+      .mockResolvedValueOnce({ rows: [] } as any) // Empty breakdown
+      .mockResolvedValueOnce({ rows: [] } as any); // Empty history
 
     const response = await request(app)
       .get("/api/score/newuser/breakdown")
@@ -88,5 +97,7 @@ describe("GET /api/score/:userId/breakdown", () => {
     expect(response.status).toBe(200);
     expect(response.body.score).toBe(500);
     expect(response.body.breakdown.totalLoans).toBe(0);
+    expect(response.body.breakdown.repaidOnTime).toBe(0);
+    expect(response.body.history).toHaveLength(0);
   });
 });
diff --git a/backend/src/controllers/scoreController.ts b/backend/src/controllers/scoreController.ts
@@ -147,6 +147,15 @@ export const updateScore = asyncHandler(async (req: Request, res: Response) => {
  * Returns a detailed breakdown of the factors contributing to the user's
  * credit score, derived from loan_events and scores tables. Gives borrowers
  * transparency into their credit profile.
+ *
+ * OPTIMIZED: Single CTE query combines all breakdown computations:
+ * - Current score fetch
+ * - Loan event aggregations (total, repaid, defaulted counts)
+ * - On-time vs late repayment classification
+ * - Average repayment time calculation
+ * - Repayment history for streak/timeline computation
+ *
+ * This reduces 6+ separate queries to 1-2 efficient round-trips.
  */
 export const getScoreBreakdown = asyncHandler(
   async (req: Request, res: Response) => {
@@ -159,153 +168,161 @@ export const getScoreBreakdown = asyncHandler(
       return;
     }
 
-    // Fetch current score
-    const scoreResult = await query(
-      "SELECT current_score FROM scores WHERE user_id = $1",
-      [userId],
-    );
-    const score =
-      scoreResult.rows.length > 0 ? scoreResult.rows[0].current_score : 500;
-    const band = getCreditBand(score);
-
-    // Fetch loan event stats for the borrower
-    const statsResult = await query(
-      `SELECT
-         COUNT(DISTINCT loan_id) FILTER (WHERE event_type = 'LoanRequested') AS total_loans,
-         COUNT(DISTINCT loan_id) FILTER (WHERE event_type = 'LoanRepaid') AS repaid_count,
-         COUNT(DISTINCT loan_id) FILTER (WHERE event_type = 'LoanDefaulted') AS defaulted_count,
-         COALESCE(SUM(CASE WHEN event_type = 'LoanRepaid' THEN CAST(amount AS NUMERIC) ELSE 0 END), 0) AS total_repaid
-       FROM loan_events
-       WHERE borrower = $1`,
-      [userId],
-    );
-
-    const stats = statsResult.rows[0] || {};
-    const totalLoans = parseInt(stats.total_loans || "0", 10);
-    const repaidCount = parseInt(stats.repaid_count || "0", 10);
-    const defaultedCount = parseInt(stats.defaulted_count || "0", 10);
-    const totalRepaid = parseFloat(stats.total_repaid || "0");
-
-    // Determine on-time vs late repayments by checking if repaid before term expiry
-    const repaymentTimingResult = await query(
-      `WITH approved AS (
-         SELECT loan_id, MAX(ledger) AS approved_ledger,
-                MAX(COALESCE(term_ledgers, 17280)) AS term_ledgers
-         FROM loan_events
-         WHERE event_type = 'LoanApproved' AND borrower = $1 AND loan_id IS NOT NULL
-         GROUP BY loan_id
+    // Single unified query that computes all breakdown metrics
+    const breakdownResult = await query(
+      `WITH 
+       -- Current score from scores table
+       current_score_cte AS (
+         SELECT COALESCE(current_score, 500) AS current_score
+         FROM scores
+         WHERE user_id = $1
        ),
-       repaid AS (
-         SELECT loan_id, MIN(ledger) AS repaid_ledger
+       -- All loan events for this borrower
+       borrower_events AS (
+         SELECT 
+           loan_id,
+           event_type,
+           ledger,
+           ledger_closed_at,
+           amount,
+           term_ledgers
          FROM loan_events
-         WHERE event_type = 'LoanRepaid' AND borrower = $1 AND loan_id IS NOT NULL
-         GROUP BY loan_id
-       )
-       SELECT
-         COUNT(*) FILTER (WHERE r.repaid_ledger <= a.approved_ledger + a.term_ledgers) AS on_time,
-         COUNT(*) FILTER (WHERE r.repaid_ledger > a.approved_ledger + a.term_ledgers) AS late
-       FROM repaid r
-       JOIN approved a ON a.loan_id = r.loan_id`,
-      [userId],
-    );
-
-    const timing = repaymentTimingResult.rows[0] || {};
-    const repaidOnTime = parseInt(timing.on_time || "0", 10);
-    const repaidLate = parseInt(timing.late || "0", 10);
-
-    // Calculate average repayment time (in ledgers, converted to approx days)
-    const avgRepayResult = await query(
-      `WITH approved AS (
-         SELECT loan_id, MAX(ledger) AS approved_ledger
-         FROM loan_events
-         WHERE event_type = 'LoanApproved' AND borrower = $1 AND loan_id IS NOT NULL
-         GROUP BY loan_id
+         WHERE borrower = $1
        ),
-       repaid AS (
-         SELECT loan_id, MIN(ledger) AS repaid_ledger
-         FROM loan_events
-         WHERE event_type = 'LoanRepaid' AND borrower = $1 AND loan_id IS NOT NULL
-         GROUP BY loan_id
-       )
-       SELECT AVG(r.repaid_ledger - a.approved_ledger) AS avg_ledgers
-       FROM repaid r
-       JOIN approved a ON a.loan_id = r.loan_id`,
-      [userId],
-    );
-
-    const avgLedgers = parseFloat(avgRepayResult.rows[0]?.avg_ledgers || "0");
-    // Convert ledger count to approximate days (1 ledger ≈ 5 seconds)
-    const avgDays = Math.round((avgLedgers * 5) / 86400);
-    const averageRepaymentTime = avgLedgers > 0 ? `${avgDays} days` : "N/A";
-
-    // Calculate repayment streaks (consecutive on-time repayments)
-    const streakResult = await query(
-      `WITH approved AS (
-         SELECT loan_id, MAX(ledger) AS approved_ledger,
-                MAX(COALESCE(term_ledgers, 17280)) AS term_ledgers
-         FROM loan_events
-         WHERE event_type = 'LoanApproved' AND borrower = $1 AND loan_id IS NOT NULL
+       -- Loan approval details (ledger and term)
+       approved_loans AS (
+         SELECT 
+           loan_id,
+           MAX(ledger) AS approved_ledger,
+           MAX(COALESCE(term_ledgers, 17280)) AS term_ledgers
+         FROM borrower_events
+         WHERE event_type = 'LoanApproved' AND loan_id IS NOT NULL
          GROUP BY loan_id
        ),
-       repaid AS (
-         SELECT loan_id, MIN(ledger) AS repaid_ledger,
-                MIN(ledger_closed_at) AS repaid_at
-         FROM loan_events
-         WHERE event_type = 'LoanRepaid' AND borrower = $1 AND loan_id IS NOT NULL
+       -- Repaid loan details (ledger and timestamp)
+       repaid_loans AS (
+         SELECT 
+           loan_id,
+           MIN(ledger) AS repaid_ledger,
+           MIN(ledger_closed_at) AS repaid_at
+         FROM borrower_events
+         WHERE event_type = 'LoanRepaid' AND loan_id IS NOT NULL
          GROUP BY loan_id
        ),
-       timeline AS (
-         SELECT r.loan_id, r.repaid_at,
-                CASE WHEN r.repaid_ledger <= a.approved_ledger + a.term_ledgers THEN true ELSE false END AS on_time
-         FROM repaid r
-         JOIN approved a ON a.loan_id = r.loan_id
-         ORDER BY r.repaid_at ASC
+       -- Classification of repayments as on-time or late
+       repayment_timing AS (
+         SELECT 
+           r.loan_id,
+           r.repaid_ledger,
+           r.repaid_at,
+           CASE WHEN r.repaid_ledger <= a.approved_ledger + a.term_ledgers 
+                THEN true ELSE false END AS on_time,
+           (r.repaid_ledger - a.approved_ledger) AS repayment_ledgers
+         FROM repaid_loans r
+         JOIN approved_loans a ON a.loan_id = r.loan_id
+       ),
+       -- Aggregate statistics across all loans
+       loan_stats AS (
+         SELECT 
+           COUNT(DISTINCT CASE WHEN event_type = 'LoanRequested' THEN loan_id END) AS total_loans,
+           COUNT(DISTINCT CASE WHEN event_type = 'LoanRepaid' THEN loan_id END) AS repaid_count,
+           COUNT(DISTINCT CASE WHEN event_type = 'LoanDefaulted' THEN loan_id END) AS defaulted_count,
+           COALESCE(SUM(CASE WHEN event_type = 'LoanRepaid' THEN CAST(amount AS NUMERIC) ELSE 0 END), 0) AS total_repaid
+         FROM borrower_events
+       ),
+       -- Repayment timing statistics
+       timing_stats AS (
+         SELECT 
+           COUNT(*) FILTER (WHERE on_time) AS on_time_count,
+           COUNT(*) FILTER (WHERE NOT on_time) AS late_count,
+           AVG(repayment_ledgers) AS avg_repayment_ledgers
+         FROM repayment_timing
+       ),
+       -- Final aggregated breakdown
+       breakdown_summary AS (
+         SELECT 
+           cs.current_score,
+           COALESCE(ls.total_loans, 0) AS total_loans,
+           COALESCE(ls.repaid_count, 0) AS repaid_count,
+           COALESCE(ls.defaulted_count, 0) AS defaulted_count,
+           COALESCE(ls.total_repaid, 0) AS total_repaid,
+           COALESCE(ts.on_time_count, 0) AS on_time_count,
+           COALESCE(ts.late_count, 0) AS late_count,
+           COALESCE(ts.avg_repayment_ledgers, 0) AS avg_repayment_ledgers
+         FROM current_score_cte cs
+         CROSS JOIN loan_stats ls
+         CROSS JOIN timing_stats ts
        )
-       SELECT on_time FROM timeline ORDER BY repaid_at ASC`,
+       SELECT 
+         current_score,
+         total_loans,
+         repaid_count,
+         defaulted_count,
+         total_repaid,
+         on_time_count,
+         late_count,
+         avg_repayment_ledgers
+       FROM breakdown_summary`,
       [userId],
     );
 
-    let longestStreak = 0;
-    let currentStreak = 0;
-    let tempStreak = 0;
-
-    for (const row of streakResult.rows) {
-      if (row.on_time) {
-        tempStreak++;
-        longestStreak = Math.max(longestStreak, tempStreak);
-      } else {
-        tempStreak = 0;
-      }
-    }
-    currentStreak = tempStreak;
+    const breakdown = breakdownResult.rows[0] || {};
+    const score = parseInt(breakdown.current_score || "500", 10);
+    const band = getCreditBand(score);
+    const totalLoans = parseInt(breakdown.total_loans || "0", 10);
+    const repaidOnTime = parseInt(breakdown.on_time_count || "0", 10);
+    const repaidLate = parseInt(breakdown.late_count || "0", 10);
+    const defaultedCount = parseInt(breakdown.defaulted_count || "0", 10);
+    const totalRepaid = parseFloat(breakdown.total_repaid || "0");
+
+    // Convert average ledgers to days (1 ledger ≈ 5 seconds)
+    const avgLedgers = parseFloat(breakdown.avg_repayment_ledgers || "0");
+    const avgDays = Math.round((avgLedgers * 5) / 86400);
+    const averageRepaymentTime = avgLedgers > 0 ? `${avgDays} days` : "N/A";
 
-    // Fetch score history from score-changing events
+    // Fetch detailed history for streak calculation (separate query is minimal overhead)
     const historyResult = await query(
-      `SELECT ledger_closed_at AS date, event_type AS event
+      `SELECT 
+         event_type,
+         ledger_closed_at
        FROM loan_events
-       WHERE borrower = $1
-         AND event_type IN ('LoanRepaid', 'LoanDefaulted')
+       WHERE borrower = $1 AND event_type IN ('LoanRepaid', 'LoanDefaulted')
        ORDER BY ledger_closed_at ASC`,
       [userId],
     );
 
     // Build score history by replaying deltas from base 500
     let runningScore = 500;
     const history = historyResult.rows.map((row: Record<string, unknown>) => {
-      if (row.event === "LoanRepaid") {
+      if (row.event_type === "LoanRepaid") {
         runningScore = Math.min(850, runningScore + ON_TIME_DELTA);
-      } else if (row.event === "LoanDefaulted") {
+      } else if (row.event_type === "LoanDefaulted") {
         runningScore = Math.max(300, runningScore - 50);
       }
       return {
-        date: row.date
-          ? new Date(row.date as string).toISOString().split("T")[0]
+        date: row.ledger_closed_at
+          ? new Date(row.ledger_closed_at as string).toISOString().split("T")[0]
           : null,
         score: runningScore,
-        event: row.event,
+        event: row.event_type,
       };
     });
 
+    // Calculate streaks from history
+    let longestStreak = 0;
+    let currentStreak = 0;
+    let tempStreak = 0;
+
+    for (const histItem of history) {
+      if (histItem.event === "LoanRepaid") {
+        tempStreak++;
+        longestStreak = Math.max(longestStreak, tempStreak);
+      } else {
+        tempStreak = 0;
+      }
+    }
+    currentStreak = tempStreak;
+
     const responseData = {
       userId,
       score,
