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/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,