Add a hotcache class that we can use to cache the most common requests.

We are using this to cache some of the most used apis - like the statistics.
This should reduce the CPU load in case of too many hits.

apps/api/src/common/hotcache.ts

@@ -0,0 +1,22 @@
+class CacheObject {
+    constructor(public value: any, public expiration: number) {}
+    isExpired() {
+        return this.expiration < Date.now()
+    }
+}
+
+export class HotCache {
+    private cache: { [key: string]: CacheObject } = {}
+
+    get(key: string) {
+        const cacheObject = this.cache[key]
+        if (cacheObject && !cacheObject.isExpired()) {
+            return cacheObject.value
+        }
+        return null
+    }
+
+    set(key: string, value: any, expiration: number) {
+        this.cache[key] = new CacheObject(value, expiration)
+    }
+}

apps/api/src/donations/donations.service.ts

@@ -29,6 +29,7 @@ import { donationWithPerson, DonationWithPerson } from './queries/donation.valid
 import { CreateStripePaymentDto } from './dto/create-stripe-payment.dto'
 import { ImportStatus } from '../bank-transactions-file/dto/bank-transactions-import-status.dto'
 import { DonationQueryDto } from '../common/dto/donation-query-dto'
+import { HotCache } from '../common/hotcache'
 
 @Injectable()
 export class DonationsService {
@@ -41,6 +42,9 @@ export class DonationsService {
     private exportService: ExportService,
   ) {}
 
+  private cache = new HotCache()
+  private cacheTimeout = 30 * 1000 // 30 seconds
+
   async listPrices(type?: Stripe.PriceListParams.Type, active?: boolean): Promise<Stripe.Price[]> {
     const listResponse = await this.stripeClient.prices.list({ active, type, limit: 100 }).then(
       function (list) {
@@ -286,6 +290,12 @@ export class DonationsService {
     pageIndex?: number,
     pageSize?: number,
   ): Promise<ListDonationsDto<DonationBaseDto>> {
+    const cacheKey = `donations-${campaignId}-${status}-${pageIndex}-${pageSize}`
+    const cachedDonations = this.cache.get(cacheKey)
+    if (cachedDonations) {
+      return cachedDonations
+    }
+
     const data = await this.prisma.donation.findMany({
       where: { status, targetVault: { campaign: { id: campaignId } } },
       orderBy: [{ createdAt: 'desc' }],
@@ -314,6 +324,8 @@ export class DonationsService {
       total: count,
     }
 
+    this.cache.set(cacheKey, result, Date.now() + this.cacheTimeout)
+
     return result
   }
 
@@ -670,16 +682,30 @@ export class DonationsService {
   }
 
   async getTotalDonatedMoney() {
+    const cachedAmount = this.cache.get('totalDonatedMoney')
+    if (cachedAmount) {
+        return { total: cachedAmount }
+    }
+
     const totalMoney = await this.prisma.donation.aggregate({
       _sum: {
         amount: true,
       },
       where: { status: DonationStatus.succeeded },
     })
+
+    // cache the amount for 30 seconds
+    this.cache.set('totalDonatedMoney', totalMoney._sum.amount, Date.now() + this.cacheTimeout)
+
     return { total: totalMoney._sum.amount }
   }
 
   async getDonorsCount() {
+    const cachedCount = this.cache.get('donorsCount')
+    if (cachedCount) {
+        return { count: cachedCount }
+    }
+
     const donorsCount = await this.prisma.donation.groupBy({
       by: ['billingName'],
       where: { status: DonationStatus.succeeded },
@@ -692,8 +718,13 @@ export class DonationsService {
     // get count of the donations with billingName == null
     const anonymousDonations = donorsCount[0]._count._all
 
+    const totalCount = donorsCount.length - 1 + anonymousDonations
+
+    // cache the count for 30 seconds
+    this.cache.set('donorsCount', totalCount, Date.now() + this.cacheTimeout)
+
     // substract one because we don't want to include anonymousDonation again
-    return { count: donorsCount.length - 1 + anonymousDonations }
+    return { count: totalCount }
   }
 
   /**