perf: implement Redis caching layer for gist queries

Backend/.env.example

@@ -117,3 +117,16 @@ THROTTLE_TTL_MS=60000
 # Maximum number of requests allowed per TTL window
 # Default: 10 requests per minute
 THROTTLE_LIMIT=10
+
+# ============================================
+# Redis Cache Configuration
+# ============================================
+
+# REDIS_URL (optional)
+# Redis connection URL for caching layer
+# Format: redis://[password@]host:port/db
+# Example: redis://localhost:6379/0
+# Example with password: redis://:password@localhost:6379/0
+# Example with ElastiCache: redis://my-cluster.xxxxxx.use1.cache.amazonaws.com:6379/0
+# Leave empty to disable caching (degrades gracefully)
+REDIS_URL=

Backend/package.json

@@ -39,6 +39,7 @@
     "cookie-parser": "^1.4.7",
     "csrf": "^3.1.0",
     "ethers": "^6.15.0",
+    "ioredis": "^5.11.1",
     "pg": "^8.13.3",
     "reflect-metadata": "^0.2.2",
     "rxjs": "^7.8.1",

Backend/src/app.module.ts

@@ -8,6 +8,7 @@ import { IpfsModule } from './ipfs/ipfs.module';
 import { SorobanModule } from './soroban/soroban.module';
 import { GistsModule } from './gists/gists.module';
 import { HealthModule } from './health/health.module';
+import { CacheModule } from './cache/cache.module';
 import { AppController } from './app.controller';
 import { AppService } from './app.service';
 
@@ -30,6 +31,7 @@ import { AppService } from './app.service';
     SorobanModule,
     GistsModule,
     HealthModule,
+    CacheModule,
   ],
   controllers: [AppController],
   providers: [

Backend/src/cache/cache.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { CacheService } from './cache.service';
+
+@Module({
+  imports: [ConfigModule],
+  providers: [CacheService],
+  exports: [CacheService],
+})
+export class CacheModule {}

Backend/src/cache/cache.service.spec.ts

@@ -0,0 +1,121 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { ConfigService } from '@nestjs/config';
+import { CacheService } from './cache.service';
+
+describe('CacheService', () => {
+  let service: CacheService;
+  let mockConfigService: jest.Mocked<ConfigService>;
+
+  beforeEach(async () => {
+    mockConfigService = {
+      get: jest.fn(),
+    } as unknown as jest.Mocked<ConfigService>;
+
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        CacheService,
+        {
+          provide: ConfigService,
+          useValue: mockConfigService,
+        },
+      ],
+    }).compile();
+
+    service = module.get<CacheService>(CacheService);
+  });
+
+  afterEach(async () => {
+    if (service) {
+      await service.onModuleDestroy();
+    }
+  });
+
+  describe('onModuleInit', () => {
+    it('should not initialize Redis when REDIS_URL is not configured', async () => {
+      mockConfigService.get.mockReturnValue(undefined);
+      await service.onModuleInit();
+      // Service should gracefully degrade without Redis
+    });
+
+    it('should handle Redis connection errors gracefully when REDIS_URL is set', async () => {
+      mockConfigService.get.mockReturnValue('redis://localhost:6379/0');
+      // Since we don't have actual Redis, this will fail but should not throw
+      await service.onModuleInit();
+      // Service should gracefully degrade
+    });
+  });
+
+  describe('get', () => {
+    it('should return null when Redis is unavailable', async () => {
+      mockConfigService.get.mockReturnValue(undefined);
+      await service.onModuleInit();
+
+      const result = await service.get('test-key');
+      expect(result).toBeNull();
+    });
+
+    it('should track cache misses when Redis is unavailable', async () => {
+      mockConfigService.get.mockReturnValue(undefined);
+      await service.onModuleInit();
+
+      await service.get('test-key');
+      const metrics = service.getMetrics();
+
+      expect(metrics.hits).toBe(0);
+      expect(metrics.misses).toBe(1);
+    });
+  });
+
+  describe('set', () => {
+    it('should not attempt set when Redis is unavailable', async () => {
+      mockConfigService.get.mockReturnValue(undefined);
+      await service.onModuleInit();
+
+      await service.set('test-key', { data: 'test' }, 60);
+      // Should not throw
+    });
+  });
+
+  describe('del', () => {
+    it('should not attempt delete when Redis is unavailable', async () => {
+      mockConfigService.get.mockReturnValue(undefined);
+      await service.onModuleInit();
+
+      await service.del('test-key');
+      // Should not throw
+    });
+  });
+
+  describe('delPattern', () => {
+    it('should not attempt pattern delete when Redis is unavailable', async () => {
+      mockConfigService.get.mockReturnValue(undefined);
+      await service.onModuleInit();
+
+      await service.delPattern('gist:nearby:*');
+      // Should not throw
+    });
+  });
+
+  describe('getMetrics', () => {
+    it('should return 0 hit rate when no requests', () => {
+      const metrics = service.getMetrics();
+      expect(metrics.hitRate).toBe(0);
+      expect(metrics.hits).toBe(0);
+      expect(metrics.misses).toBe(0);
+    });
+  });
+
+  describe('resetMetrics', () => {
+    it('should reset hit and miss counters', async () => {
+      mockConfigService.get.mockReturnValue(undefined);
+      await service.onModuleInit();
+
+      await service.get('test-key');
+      service.resetMetrics();
+      const metrics = service.getMetrics();
+
+      expect(metrics.hits).toBe(0);
+      expect(metrics.misses).toBe(0);
+    });
+  });
+});