feat: implement Redis caching for business activities and consumers

- Added Redis caching to BusinessActivitiesService for findAll and findOne methods.
- Integrated Redis caching in BusinessActivityComplexesService for findAll and findOne methods.
- Enhanced ConsumersService with Redis caching for findAll and findOne methods.
- Introduced cache invalidation for partner consumers and business activities.
- Created RedisKeyMaker utility for generating cache keys for consumers, partners, and POS.
- Implemented cache invalidation services for partners and POS.
- Added Redis service methods for JSON handling and key deletion by patterns.
- Updated goods service to include caching and invalidation for goods list.
- Introduced DTO for updating goods.

src/modules/admin/partners/activatedLicenses/activatedLicenses.service.ts

@@ -1,15 +1,30 @@
 import { QUERY_CONSTANTS } from '@/common/queryConstants'
 import consumer_mappersUtil from '@/common/utils/mappers/consumer_mappers.util'
+import { RedisKeyMaker } from '@/common/utils/redisKeyMaker'
 import { LicenseActivationWhereInput } from '@/generated/prisma/models'
+import { PartnersCacheInvalidationService } from '@/modules/partners/cache/partners-cache-invalidation.service'
 import { PrismaService } from '@/prisma/prisma.service'
+import { RedisService } from '@/redis/redis.service'
 import { Injectable } from '@nestjs/common'
 import { ResponseMapper } from 'common/response/response-mapper'
 
 @Injectable()
 export class PartnerActivatedLicensesService {
-  constructor(private readonly prisma: PrismaService) {}
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly redisService: RedisService,
+    private readonly cacheInvalidationService: PartnersCacheInvalidationService,
+  ) {}
 
   async findAll(partner_id: string, page = 1, perPage = 10) {
+    const cacheKey = RedisKeyMaker.partnerActivatedLicensesList(partner_id, page, perPage)
+    const cached = await this.redisService.getJson<{ data: unknown[]; total: number }>(
+      cacheKey,
+    )
+    if (cached) {
+      return ResponseMapper.paginate(cached.data, { page, perPage, total: cached.total })
+    }
+
     const defaultWhere: LicenseActivationWhereInput = {
       license: {
         charge_transaction: {
@@ -73,6 +88,8 @@ export class PartnerActivatedLicensesService {
       }
     })
 
+    await this.redisService.setJson(cacheKey, { data: mappedLicenses, total }, 300)
+
     return ResponseMapper.paginate(mappedLicenses, {
       page,
       perPage,
@@ -90,6 +107,7 @@ export class PartnerActivatedLicensesService {
 
   async delete(partnerId: string, id: string) {
     await this.prisma.license.delete({ where: { id } })
+    await this.cacheInvalidationService.invalidatePartnerLicenses(partnerId)
     return ResponseMapper.delete()
   }
 }

src/modules/admin/partners/chargedLicenseTransactions/chargedLicenseTransactions.service.ts

@@ -1,3 +1,4 @@
+import { RedisKeyMaker } from '@/common/utils/redisKeyMaker'
 import {
   generateTrackingCode,
   isTrackingCodeUniqueViolation,
@@ -6,14 +7,20 @@ import {
   LicenseChargeTransactionSelect,
   LicenseChargeTransactionWhereInput,
 } from '@/generated/prisma/models'
+import { PartnersCacheInvalidationService } from '@/modules/partners/cache/partners-cache-invalidation.service'
 import { PrismaService } from '@/prisma/prisma.service'
+import { RedisService } from '@/redis/redis.service'
 import { BadRequestException, Injectable } from '@nestjs/common'
 import { ResponseMapper } from 'common/response/response-mapper'
 import { ChargeLicenseDto } from './dto/chargedLicenseTransactions.dto'
 
 @Injectable()
 export class PartnerLicenseChargeTransactionService {
-  constructor(private readonly prisma: PrismaService) {}
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly redisService: RedisService,
+    private readonly cacheInvalidationService: PartnersCacheInvalidationService,
+  ) {}
 
   private readonly TRACKING_CODE_LENGTH = 8
   private readonly TRACKING_CODE_MAX_ATTEMPTS = 5
@@ -53,6 +60,18 @@ export class PartnerLicenseChargeTransactionService {
   }
 
   async findAll(partner_id: string, page = 1, perPage = 10) {
+    const cacheKey = RedisKeyMaker.partnerLicenseChargeTransactionsList(
+      partner_id,
+      page,
+      perPage,
+    )
+    const cached = await this.redisService.getJson<{ data: unknown[]; total: number }>(
+      cacheKey,
+    )
+    if (cached) {
+      return ResponseMapper.paginate(cached.data, { page, perPage, total: cached.total })
+    }
+
     const defaultWhere: LicenseChargeTransactionWhereInput = {
       partner_id,
     }
@@ -70,6 +89,7 @@ export class PartnerLicenseChargeTransactionService {
     ])
 
     const mappedTransactions = transactions.map(this.mappedTransaction)
+    await this.redisService.setJson(cacheKey, { data: mappedTransactions, total }, 300)
 
     return ResponseMapper.paginate(mappedTransactions, {
       page,
@@ -79,6 +99,12 @@ export class PartnerLicenseChargeTransactionService {
   }
 
   async findOne(partner_id: string, id: string) {
+    const cacheKey = RedisKeyMaker.partnerLicenseChargeTransactionDetail(partner_id, id)
+    const cached = await this.redisService.getJson<unknown>(cacheKey)
+    if (cached) {
+      return ResponseMapper.single(cached)
+    }
+
     const transaction = await this.prisma.licenseChargeTransaction.findUniqueOrThrow({
       where: {
         id,
@@ -86,7 +112,9 @@ export class PartnerLicenseChargeTransactionService {
       },
       select: this.defaultSelect,
     })
-    return ResponseMapper.single(this.mappedTransaction(transaction))
+    const mappedTransaction = this.mappedTransaction(transaction)
+    await this.redisService.setJson(cacheKey, mappedTransaction, 300)
+    return ResponseMapper.single(mappedTransaction)
   }
 
   async create(partner_id: string, data: ChargeLicenseDto) {
@@ -134,6 +162,8 @@ export class PartnerLicenseChargeTransactionService {
       })
 
       this.scheduleLicenseProvisioning(transaction.id, transaction.purchased_count)
+      await this.cacheInvalidationService.invalidatePartnersList()
+      await this.cacheInvalidationService.invalidatePartnerLicenses(partner_id)
       return ResponseMapper.create({
         transaction_id: transaction.id,
         charged_license_count: transaction.purchased_count,

src/modules/admin/partners/partners.service.ts

@@ -1,6 +1,7 @@
 import { UploadedFileTypes } from '@/common/enums/enums'
 import { translateEnumValue } from '@/common/utils'
 import { PasswordUtil } from '@/common/utils/password.util'
+import { RedisKeyMaker } from '@/common/utils/redisKeyMaker'
 import {
   AccountStatus,
   AccountType,
@@ -8,8 +9,10 @@ import {
   PartnerStatus,
 } from '@/generated/prisma/enums'
 import { PartnerSelect } from '@/generated/prisma/models'
+import { PartnersCacheInvalidationService } from '@/modules/partners/cache/partners-cache-invalidation.service'
 import { UploaderService } from '@/modules/uploader/uploader.service'
 import { PrismaService } from '@/prisma/prisma.service'
+import { RedisService } from '@/redis/redis.service'
 import { Injectable } from '@nestjs/common'
 import { ResponseMapper } from 'common/response/response-mapper'
 import { CreatePartnerDto, UpdatePartnerDto } from './dto/partner.dto'
@@ -20,6 +23,8 @@ export class PartnersService {
   constructor(
     private readonly prisma: PrismaService,
     private readonly uploaderService: UploaderService,
+    private readonly redisService: RedisService,
+    private readonly cacheInvalidationService: PartnersCacheInvalidationService,
   ) {}
 
   private readonly defaultSelect: PartnerSelect = {
@@ -137,22 +142,40 @@ export class PartnersService {
   }
 
   async findAll() {
+    const cacheKey = RedisKeyMaker.partnersList()
+    const cached = await this.redisService.getJson<unknown[]>(cacheKey)
+    if (cached) {
+      console.log('cached', cached)
+
+      return ResponseMapper.list(cached)
+    }
+
     const partners = await this.prisma.partner.findMany({
       select: this.defaultSelect,
     })
 
     const mappedPartners = partners.map(this.mapPartner)
+    await this.redisService.setJson(cacheKey, mappedPartners, 300)
 
     return ResponseMapper.list(mappedPartners)
   }
 
   async findOne(id: string) {
+    const cacheKey = RedisKeyMaker.partnerDetail(id)
+    const cached = await this.redisService.getJson<unknown>(cacheKey)
+    if (cached) {
+      return ResponseMapper.single(cached)
+    }
+
     const partner = await this.prisma.partner.findUniqueOrThrow({
       where: { id },
       select: this.defaultSelect,
     })
 
-    return ResponseMapper.single(this.mapPartner(partner))
+    const mappedPartner = this.mapPartner(partner)
+    await this.redisService.setJson(cacheKey, mappedPartner, 300)
+
+    return ResponseMapper.single(mappedPartner)
   }
 
   async create(data: CreatePartnerDto, logo?: any) {
@@ -184,6 +207,8 @@ export class PartnersService {
       },
       select: this.defaultSelect,
     })
+    await this.cacheInvalidationService.invalidatePartnersList()
+    await this.cacheInvalidationService.invalidatePartnerDetail(partner.id)
     return ResponseMapper.create(partner)
   }
 
@@ -220,11 +245,17 @@ export class PartnersService {
       })
     })
 
+    await this.cacheInvalidationService.invalidatePartnersList()
+    await this.cacheInvalidationService.invalidatePartnerDetail(id)
+
     return ResponseMapper.update(partner)
   }
 
   async delete(id: string) {
     await this.prisma.partner.delete({ where: { id } })
+    await this.cacheInvalidationService.invalidatePartnersList()
+    await this.cacheInvalidationService.invalidatePartnerDetail(id)
+    await this.cacheInvalidationService.invalidatePartnerLicenses(id)
     return ResponseMapper.delete()
   }
 }