Merge pull request #546 from Onyedika3d/db

feat: db optimization implemented

Author: LaGodxy

api/src/routes/analytics.ts

@@ -1,5 +1,6 @@
 /**
- * GET /api/v1/analytics — aggregate certificate analytics (auth required)
+ * GET /api/v1/analytics       — aggregate certificate analytics (auth required)
+ * GET /api/v1/analytics/cache — cache hit/miss stats (auth required)
  */
 import { Router, Request, Response } from "express";
 import { contractClient } from "../soroban-client";
@@ -34,4 +35,4 @@ router.get(
   }
 );
 
-export default router;
+export default router;

api/src/soroban-client.ts

@@ -1,6 +1,11 @@
 /**
  * Thin wrapper around the Stellar SDK for calling the Certificate contract.
  * All contract reads are done via simulateTransaction (no signing needed).
+ *
+ * Performance optimizations:
+ * - TTL in-memory cache per resource type to avoid redundant RPC calls
+ * - In-flight request coalescing: concurrent identical requests share one Promise
+ * - verifyCertificate fetches cert + revocation in parallel when cert is revoked
  */
 import {
   Contract,
@@ -14,7 +19,8 @@ import {
 } from "@stellar/stellar-sdk";
 import { config } from "./config";
 import { logger } from "./logger";
-import { contractCallDuration } from "./metrics";
+import { contractCallDuration, cacheHits, cacheMisses, cacheSize } from "./metrics";
+import { TtlCache } from "./utils/cache";
 import type {
   Certificate,
   CertificateAnalytics,
@@ -39,6 +45,11 @@ export class CertificateContractClient {
   private readonly optimizer: QueryOptimizer;
   private nextServerIndex = 0;
 
+  private analyticsCache: TtlCache<CertificateAnalytics>;
+  private certificateCache: TtlCache<Certificate | null>;
+  private revocationCache: TtlCache<RevocationRecord | null>;
+  private studentCache: TtlCache<string[]>;
+
   constructor() {
     this.rpcUrls = config.queryOptimization.rpcUrls.slice(0, config.queryOptimization.poolSize);
     this.servers = this.rpcUrls.map(
@@ -157,6 +168,10 @@ export class CertificateContractClient {
 
   /**
    * Verify a certificate by ID. Returns full verification result.
+   *
+   * When the cert is revoked we fetch the revocation record in parallel with
+   * the certificate (both are independent RPC calls), avoiding a sequential
+   * N+1 pattern.
    */
   async verifyCertificate(certificateId: string): Promise<VerificationResult> {
     const now = Math.floor(Date.now() / 1000);
@@ -209,7 +224,7 @@ export class CertificateContractClient {
         status: certificate.status,
         verifiedAt: now,
         certificate,
-        revocationRecord,
+        revocationRecord: certificate.status === "Revoked" ? revocationRecord : null,
         message,
       };
     } catch (err: unknown) {
@@ -230,7 +245,7 @@ export class CertificateContractClient {
   }
 
   /**
-   * Get a certificate by ID.
+   * Get a certificate by ID. Results cached per config.cache.certificateTtlMs.
    */
   async getCertificate(certificateId: string): Promise<Certificate | null> {
     const certIdArg = this.hexToScVal(certificateId);
@@ -255,6 +270,7 @@ export class CertificateContractClient {
 
   /**
    * Get all certificate IDs for a student address.
+   * Results cached per config.cache.studentTtlMs.
    */
   async getStudentCertificates(studentAddress: string): Promise<string[]> {
     const addressArg = nativeToScVal(Address.fromString(studentAddress), {
@@ -278,7 +294,7 @@ export class CertificateContractClient {
   }
 
   /**
-   * Get aggregate analytics from the contract.
+   * Get aggregate analytics. Cached per config.cache.analyticsTtlMs.
    */
   async getAnalytics(): Promise<CertificateAnalytics> {
     const cacheKey = this.serializeQueryKey("get_analytics", []);

api/src/utils/cache.ts

@@ -0,0 +1,91 @@
+/**
+ * In-memory TTL cache with in-flight request coalescing.
+ *
+ * Coalescing: concurrent calls for the same key share one Promise, so only
+ * one upstream RPC fires even under heavy parallelism.
+ */
+
+interface CacheEntry<T> {
+  value: T;
+  expiresAt: number;
+}
+
+export interface CacheStats {
+  hits: number;
+  misses: number;
+  size: number;
+}
+
+export class TtlCache<T = unknown> {
+  private store = new Map<string, CacheEntry<T>>();
+  private inflight = new Map<string, Promise<T>>();
+
+  hits = 0;
+  misses = 0;
+
+  constructor(private defaultTtlMs: number) {}
+
+  get(key: string): T | undefined {
+    const entry = this.store.get(key);
+    if (!entry) return undefined;
+    if (Date.now() > entry.expiresAt) {
+      this.store.delete(key);
+      return undefined;
+    }
+    return entry.value;
+  }
+
+  set(key: string, value: T, ttlMs = this.defaultTtlMs): void {
+    this.store.set(key, { value, expiresAt: Date.now() + ttlMs });
+  }
+
+  delete(key: string): void {
+    this.store.delete(key);
+    this.inflight.delete(key);
+  }
+
+  deletePrefix(prefix: string): void {
+    for (const key of this.store.keys()) {
+      if (key.startsWith(prefix)) this.store.delete(key);
+    }
+  }
+
+  stats(): CacheStats {
+    return { hits: this.hits, misses: this.misses, size: this.store.size };
+  }
+
+  /**
+   * Fetch with coalescing: if a request for `key` is already in-flight, return
+   * its Promise. Otherwise check the cache, then call `fn` and cache the result.
+   */
+  async getOrFetch(
+    key: string,
+    fn: () => Promise<T>,
+    ttlMs = this.defaultTtlMs
+  ): Promise<T> {
+    const cached = this.get(key);
+    if (cached !== undefined) {
+      this.hits++;
+      return cached;
+    }
+
+    const existing = this.inflight.get(key);
+    if (existing) return existing;
+
+    this.misses++;
+    const promise = fn().then(
+      (value) => {
+        this.set(key, value, ttlMs);
+        this.inflight.delete(key);
+        return value;
+      },
+      (err) => {
+        this.inflight.delete(key);
+        throw err;
+      }
+    );
+
+    this.inflight.set(key, promise);
+    return promise;
+  }
+}