Merge branch 'main' into test/get-contribution-coverage

Author: ritik4ever

README.md

@@ -99,6 +99,18 @@ stellar contract invoke --id $CONTRACT_ID -- update_metadata \
 
 The contract emits a `MetadataUpdated` event containing both the old and new metadata values. The backend event indexer processes this event and updates local state automatically.
 
+### Multi-token campaigns (issue #191)
+
+Campaigns can accept more than one Stellar asset code. When `acceptedTokens` contains multiple entries the frontend renders a per-token progress bar beneath the main progress bar, and the pledge form shows a token selector so contributors can choose which asset to pledge.
+
+The backend tracks per-token pledge totals in the `tokenBalances` field (a `Record<assetCode, amount>` map built from the `pledges` table grouped by `asset_code`). This is returned on every `GET /api/campaigns/:id` response and on the campaign list.
+
+**Contract side:** The Soroban contract stores `accepted_tokens: Vec<String>` on each campaign. `contribute()` validates that the pledged asset is in the list before recording the pledge.
+
+**Frontend side:** `CampaignCard` renders individual `<div class="progress-bar">` elements for each accepted token when `tokenBalances` is present. `CampaignDetailPanel` conditionally shows a `<select>` token picker above the amount field when `acceptedTokens.length > 1`.
+
+**Backend side:** `getCampaignTokenBalances(campaignId)` queries the `pledges` table grouped by `asset_code` and returns the map. `getCampaign()` populates `campaign.tokenBalances` on every read.
+
 ### Deadline extension governance (issue #192)
 
 Any existing contributor can request a deadline extension:
@@ -203,6 +215,26 @@ Base URL:
 - `status` is `ok` when the API and database probe succeed, otherwise `degraded`
 - `database.status` is `up` or `down` based on a lightweight SQLite reachability check
 
+### `GET /api/stats`
+
+- Returns aggregate metrics and totals computed from campaigns and pledges.
+- Cached with a 30-second TTL.
+- Response:
+
+```json
+{
+  "data": {
+    "totalCampaigns": 10,
+    "openCampaigns": 5,
+    "fundedCampaigns": 3,
+    "claimedCampaigns": 1,
+    "failedCampaigns": 1,
+    "totalPledgeVolume": 50000,
+    "uniqueContributors": 42
+  }
+}
+```
+
 ### `GET /api/campaigns`
 
 - Returns all campaigns with computed progress

backend/package-lock.json

@@ -10,6 +10,7 @@
     "cors": "^2.8.5",
     "dotenv": "^17.3.1",
     "express": "^4.21.2",
+    "lru-cache": "^11.5.1",
     "redis": "^4.6.13",
     "zod": "^4.3.6"
   },

backend/package.json

@@ -420,3 +420,19 @@ describe('Campaign maxPerContributor Field', () => {
     expect(detailRes.data.data.maxPerContributor).toBe(75);
   });
 });
+
+describe('GET /api/stats', () => {
+  it('returns aggregate metrics in the correct format', async () => {
+    const res = await get('/api/stats');
+    expect(res.status).toBe(200);
+    expect(res.data.data).toMatchObject({
+      totalCampaigns: expect.any(Number),
+      openCampaigns: expect.any(Number),
+      fundedCampaigns: expect.any(Number),
+      claimedCampaigns: expect.any(Number),
+      failedCampaigns: expect.any(Number),
+      totalPledgeVolume: expect.any(Number),
+      uniqueContributors: expect.any(Number),
+    });
+  });
+});

backend/src/api.test.ts

@@ -58,6 +58,12 @@ import {
   normalizeQueryValue,
 } from './validation/schemas';
 import { logError, logInfo } from './logger';
+import {
+  buildCampaignCacheKey,
+  getCampaignCacheEntry,
+  invalidateCampaignCache,
+  setCampaignCacheEntry,
+} from './services/campaignCache';
 export const app = express();
 
 type CampaignListItem = CampaignRecord & { progress: CampaignProgress };
@@ -270,6 +276,22 @@ app.get('/api/campaigns', (req: Request, res: Response) => {
 
   const params = queryResult.data;
 
+  // Build a stable cache key from the sorted query string
+  const qs = Object.keys(req.query as Record<string, unknown>)
+    .sort()
+    .map((k) => `${k}=${(req.query as Record<string, unknown>)[k]}`)
+    .join('&');
+  const cacheKey = buildCampaignCacheKey(qs);
+
+  const cached = getCampaignCacheEntry(cacheKey);
+  if (cached) {
+    res.setHeader('Cache-Control', 'max-age=5');
+    res.setHeader('X-Cache', 'HIT');
+    res.setHeader('Content-Type', 'application/json');
+    res.send(cached);
+    return;
+  }
+
   const listOptions: ListCampaignsOptions = {
     searchQuery: params.search || params.q,
     assetCodes: params.asset,
@@ -299,7 +321,7 @@ app.get('/api/campaigns', (req: Request, res: Response) => {
       ? 1
       : Math.max(1, Math.ceil(totalCount / limit));
 
-  res.json({
+  const responseBody = JSON.stringify({
     data,
     pagination: {
       total: totalCount,
@@ -308,6 +330,13 @@ app.get('/api/campaigns', (req: Request, res: Response) => {
       totalPages,
     },
   });
+
+  setCampaignCacheEntry(cacheKey, responseBody);
+
+  res.setHeader('Cache-Control', 'max-age=5');
+  res.setHeader('X-Cache', 'MISS');
+  res.setHeader('Content-Type', 'application/json');
+  res.send(responseBody);
 });
 
 app.get('/api/campaigns/:id', (req: Request, res: Response) => {
@@ -382,6 +411,7 @@ app.post('/api/campaigns', (req: Request, res: Response) => {
   };
 
   const campaign = createCampaign(campaignInput);
+  invalidateCampaignCache();
   res.status(201).json({ data: { ...campaign, progress: calculateProgress(campaign) } });
 });
 
@@ -400,6 +430,7 @@ app.post(
     }
 
     const campaign = addPledge(parsedId.value, parsedBody.data);
+    invalidateCampaignCache();
     res.status(201).json({ data: { ...campaign, progress: calculateProgress(campaign) } });
   },
 );
@@ -419,6 +450,7 @@ app.post(
     }
 
     const campaign = reconcileOnChainPledge(parsedId.value, parsedBody.data);
+    invalidateCampaignCache();
     res.status(201).json({
       data: {
         campaign: { ...campaign, progress: calculateProgress(campaign) },
@@ -447,6 +479,7 @@ app.post(
       transactionHash: parsedBody.data.transactionHash,
       confirmedAt: parsedBody.data.confirmedAt,
     });
+    invalidateCampaignCache();
     res.json({ data: { ...campaign, progress: calculateProgress(campaign) } });
   },
 );
@@ -476,6 +509,7 @@ app.post(
         latestLedger: verified.latestLedger ?? parsedBody.data.soroban.latestLedger,
         source: 'soroban-contract',
       });
+      invalidateCampaignCache();
 
       res.json({
         data: {
@@ -554,9 +588,19 @@ app.get('/api/config', (_req: Request, res: Response) => {
   });
 });
 
-app.get('/api/stats', (_req: Request, res: Response) => {
+app.get('/api/stats', cacheMiddleware(30), (_req: Request, res: Response) => {
   const stats = getGlobalStats();
-  res.json({ data: stats });
+  res.json({
+    data: {
+      totalCampaigns: stats.totalCampaigns,
+      openCampaigns: stats.campaignCountByStatus.open,
+      fundedCampaigns: stats.campaignCountByStatus.funded,
+      claimedCampaigns: stats.campaignCountByStatus.claimed,
+      failedCampaigns: stats.campaignCountByStatus.failed,
+      totalPledgeVolume: stats.totalPledgedAmount,
+      uniqueContributors: stats.totalContributors,
+    }
+  });
 });
 
 app.get('/api/leaderboard', (req: Request, res: Response) => {

backend/src/index.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import {
+  buildCampaignCacheKey,
+  getCampaignCacheEntry,
+  setCampaignCacheEntry,
+  invalidateCampaignCache,
+  getCampaignCacheSize,
+} from './campaignCache';
+
+describe('campaignCache', () => {
+  beforeEach(() => {
+    invalidateCampaignCache();
+  });
+
+  it('returns undefined for a key that has not been set', () => {
+    expect(getCampaignCacheEntry('campaigns:missing')).toBeUndefined();
+  });
+
+  it('returns the stored body after a set', () => {
+    const key = buildCampaignCacheKey('status=open');
+    const body = JSON.stringify({ data: [], pagination: {} });
+    setCampaignCacheEntry(key, body);
+    expect(getCampaignCacheEntry(key)).toBe(body);
+  });
+
+  it('buildCampaignCacheKey namespaces the key correctly', () => {
+    expect(buildCampaignCacheKey('foo=bar')).toBe('campaigns:foo=bar');
+    expect(buildCampaignCacheKey('')).toBe('campaigns:');
+  });
+
+  it('stores separate entries for different query strings', () => {
+    const k1 = buildCampaignCacheKey('status=open');
+    const k2 = buildCampaignCacheKey('status=funded');
+    setCampaignCacheEntry(k1, 'open-response');
+    setCampaignCacheEntry(k2, 'funded-response');
+    expect(getCampaignCacheEntry(k1)).toBe('open-response');
+    expect(getCampaignCacheEntry(k2)).toBe('funded-response');
+  });
+
+  it('invalidateCampaignCache clears all entries', () => {
+    setCampaignCacheEntry(buildCampaignCacheKey('a=1'), 'body-a');
+    setCampaignCacheEntry(buildCampaignCacheKey('b=2'), 'body-b');
+    expect(getCampaignCacheSize()).toBe(2);
+
+    invalidateCampaignCache();
+
+    expect(getCampaignCacheSize()).toBe(0);
+    expect(getCampaignCacheEntry(buildCampaignCacheKey('a=1'))).toBeUndefined();
+  });
+
+  it('overwrites an existing entry for the same key', () => {
+    const key = buildCampaignCacheKey('page=1');
+    setCampaignCacheEntry(key, 'first');
+    setCampaignCacheEntry(key, 'second');
+    expect(getCampaignCacheEntry(key)).toBe('second');
+  });
+});

backend/src/middleware/requestLogging.ts

@@ -0,0 +1,33 @@
+import { LRUCache } from 'lru-cache';
+
+const CACHE_TTL_MS = 5_000;
+const CACHE_MAX_SIZE = Number(process.env.CAMPAIGN_CACHE_MAX_SIZE ?? 100);
+
+interface CacheEntry {
+  body: string;
+}
+
+const cache = new LRUCache<string, CacheEntry>({
+  max: CACHE_MAX_SIZE,
+  ttl: CACHE_TTL_MS,
+});
+
+export function buildCampaignCacheKey(queryString: string): string {
+  return `campaigns:${queryString}`;
+}
+
+export function getCampaignCacheEntry(key: string): string | undefined {
+  return cache.get(key)?.body;
+}
+
+export function setCampaignCacheEntry(key: string, body: string): void {
+  cache.set(key, { body });
+}
+
+export function invalidateCampaignCache(): void {
+  cache.clear();
+}
+
+export function getCampaignCacheSize(): number {
+  return cache.size;
+}

backend/src/services/campaignCache.test.ts

@@ -38,6 +38,7 @@ export function initDb(): void {
   // This is the chosen journal mode to prevent unnecessary lock contention,
   // allowing reads and writes to occur concurrently without blocking each other.
   db.pragma('journal_mode = WAL');
+  db.pragma('synchronous = NORMAL');
   db.pragma('foreign_keys = ON');
 
   migrate(db);

backend/src/services/campaignCache.ts

@@ -0,0 +1,41 @@
+import path from 'path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+const TEST_DB = path.join('/tmp', `sgv-wal-test-${process.pid}.db`);
+
+describe('SQLite WAL configuration (#218)', () => {
+  beforeEach(() => {
+    process.env.DB_PATH = TEST_DB;
+  });
+
+  afterEach(async () => {
+    const { resetDbForTests } = await import('./db');
+    resetDbForTests();
+    const fs = await import('fs');
+    fs.rmSync(TEST_DB, { force: true });
+    fs.rmSync(`${TEST_DB}-wal`, { force: true });
+    fs.rmSync(`${TEST_DB}-shm`, { force: true });
+  });
+
+  it('enables WAL journal mode on init', async () => {
+    const { initDb, getDb } = await import('./db');
+    initDb();
+    const row = getDb().pragma('journal_mode', { simple: true });
+    expect(row).toBe('wal');
+  });
+
+  it('sets synchronous=NORMAL on init', async () => {
+    const { initDb, getDb } = await import('./db');
+    initDb();
+    const row = getDb().pragma('synchronous', { simple: true });
+    // 1 = NORMAL in SQLite pragma integer encoding
+    expect(row).toBe(1);
+  });
+
+  it('enables foreign key enforcement on init', async () => {
+    const { initDb, getDb } = await import('./db');
+    initDb();
+    const row = getDb().pragma('foreign_keys', { simple: true });
+    expect(row).toBe(1);
+  });
+});