feat: implement NestJS API gateway with chat and assets services

- Add Twitch service to connect to IRC and relay chat events via WebSocket
- Introduce token manager for Twitch API authentication with scheduled refresh
- Implement emote cache service to fetch and store channel assets (badges, emotes)
- Create WebSocket gateway for real-time chat communication with rooms
- Add assets controller to expose cached channel assets via REST API
- Configure Redis caching with fallback to in-memory storage
- Set up proxy to legacy Express app for Strangler Fig migration pattern
- Update package dependencies and add Docker commands for Redis service

Author: christopherldo

apps/api/package.json

@@ -6,21 +6,40 @@
     "dev": "nest start --watch",
     "build": "nest build",
     "start": "node dist/main.js",
-    "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix"
+    "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
   "dependencies": {
+    "@fastify/cors": "^11.2.0",
+    "@fastify/http-proxy": "^11.4.4",
+    "@nestjs/cache-manager": "^3.1.2",
     "@nestjs/common": "^11.0.0",
+    "@nestjs/config": "^4.0.4",
     "@nestjs/core": "^11.0.0",
     "@nestjs/platform-fastify": "^11.0.0",
+    "@nestjs/platform-socket.io": "^11.1.19",
+    "@nestjs/schedule": "^6.1.3",
+    "@nestjs/websockets": "^11.1.19",
+    "@twitch-chat-visualizer/shared": "workspace:*",
+    "axios": "^0.21.4",
+    "cache-manager": "^7.2.8",
+    "cache-manager-redis-yet": "^5.1.5",
     "fastify": "^5.0.0",
     "reflect-metadata": "^0.2.0",
     "rxjs": "^7.8.1",
-    "@twitch-chat-visualizer/shared": "workspace:*"
+    "socket.io": "^3.1.2",
+    "tmi.js": "^1.8.5"
   },
   "devDependencies": {
     "@nestjs/cli": "^11.0.0",
+    "@twitch-chat-visualizer/config-ts": "workspace:*",
     "@types/node": "^22.0.0",
+    "@types/tmi.js": "^1.8.6",
+    "@vitest/ui": "^4.1.5",
+    "socket.io-client": "^4.8.3",
     "typescript": "^5.4.0",
-    "@twitch-chat-visualizer/config-ts": "workspace:*"
+    "unplugin-swc": "^1.5.9",
+    "vitest": "^4.1.5"
   }
 }

apps/api/src/app.module.ts

@@ -1,9 +1,45 @@
 import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { ScheduleModule } from '@nestjs/schedule';
+import { CacheModule } from '@nestjs/cache-manager';
+import { redisStore } from 'cache-manager-redis-yet';
 import { AppController } from './app.controller';
+import { AssetsController } from './controllers/assets.controller';
+import { AuthModule } from './auth/auth.module';
+import { CacheExtModule } from './cache/cache.module';
+import { TwitchModule } from './twitch/twitch.module';
+import { GatewaysModule } from './gateways/gateways.module';
 
 @Module({
-  imports: [],
-  controllers: [AppController],
+  imports: [
+    ConfigModule.forRoot({
+      isGlobal: true,
+      envFilePath: '../../.env', // Pode ler da raiz do monorepo se desejar
+    }),
+    ScheduleModule.forRoot(),
+    CacheModule.registerAsync({
+      isGlobal: true,
+      useFactory: async () => {
+        try {
+          const store = await redisStore({
+            url: process.env.REDIS_URL || 'redis://localhost:6379',
+            socket: {
+              reconnectStrategy: () => new Error('Redis not available'),
+            }
+          });
+          return { store };
+        } catch (error) {
+          console.warn('⚠️  Redis connection failed, falling back to in-memory cache.');
+          return {}; // Retornar um objeto vazio instrui o cache-manager a usar o cache em memória padrão do Node
+        }
+      },
+    }),
+    AuthModule,
+    CacheExtModule,
+    TwitchModule,
+    GatewaysModule,
+  ],
+  controllers: [AppController, AssetsController],
   providers: [],
 })
 export class AppModule {}

apps/api/src/auth/auth.module.ts

@@ -0,0 +1,8 @@
+import { Module } from '@nestjs/common';
+import { TokenManagerService } from './token-manager.service';
+
+@Module({
+  providers: [TokenManagerService],
+  exports: [TokenManagerService],
+})
+export class AuthModule {}

apps/api/src/auth/token-manager.service.spec.ts

@@ -0,0 +1,38 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { TokenManagerService } from './token-manager.service';
+import { ConfigService } from '@nestjs/config';
+
+describe('TokenManagerService', () => {
+  let tokenManagerService: TokenManagerService;
+  let mockCacheManager: any;
+  let mockConfigService: any;
+
+  beforeEach(() => {
+    mockCacheManager = {
+      get: vi.fn(),
+      set: vi.fn(),
+    };
+
+    mockConfigService = {
+      get: vi.fn().mockImplementation((key: string) => {
+        if (key === 'TWITCH_CLIENT_ID') return 'mock-client-id';
+        if (key === 'TWITCH_CLIENT_SECRET') return 'mock-client-secret';
+        return null;
+      }),
+    };
+
+    tokenManagerService = new TokenManagerService(
+      mockConfigService as unknown as ConfigService,
+      mockCacheManager
+    );
+  });
+
+  it('should return token from cache if available', async () => {
+    mockCacheManager.get.mockResolvedValue('cached-token');
+
+    const token = await tokenManagerService.getToken();
+
+    expect(mockCacheManager.get).toHaveBeenCalledWith('TWITCH_APP_ACCESS_TOKEN');
+    expect(token).toBe('cached-token');
+  });
+});

apps/api/src/auth/token-manager.service.ts

@@ -0,0 +1,79 @@
+import { Injectable, Logger, OnModuleInit } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { Cron, CronExpression } from '@nestjs/schedule';
+import { Inject } from '@nestjs/common';
+import { CACHE_MANAGER } from '@nestjs/cache-manager';
+import { Cache } from 'cache-manager';
+import axios from 'axios';
+import qs from 'qs';
+
+@Injectable()
+export class TokenManagerService implements OnModuleInit {
+  private readonly logger = new Logger(TokenManagerService.name);
+  private readonly TOKEN_KEY = 'TWITCH_APP_ACCESS_TOKEN';
+
+  constructor(
+    private readonly configService: ConfigService,
+    @Inject(CACHE_MANAGER) private cacheManager: Cache,
+  ) {}
+
+  async onModuleInit() {
+    await this.ensureTokenValid();
+  }
+
+  async getToken(): Promise<string> {
+    let token = await this.cacheManager.get<string>(this.TOKEN_KEY);
+    if (!token) {
+      token = await this.refreshToken();
+    }
+    return token;
+  }
+
+  // Executa a cada 30 minutos para garantir que o token esteja sempre válido (eles duram ~60 dias, mas é bom previnir)
+  @Cron(CronExpression.EVERY_30_MINUTES)
+  async ensureTokenValid() {
+    const token = await this.cacheManager.get<string>(this.TOKEN_KEY);
+    if (!token) {
+      await this.refreshToken();
+    }
+  }
+
+  private async refreshToken(): Promise<string> {
+    this.logger.log('Fetching new Twitch App Access Token...');
+    
+    const clientId = this.configService.get<string>('TWITCH_CLIENT_ID');
+    const clientSecret = this.configService.get<string>('TWITCH_CLIENT_SECRET');
+
+    if (!clientId || !clientSecret) {
+      this.logger.error('Missing TWITCH_CLIENT_ID or TWITCH_CLIENT_SECRET in .env');
+      return '';
+    }
+
+    try {
+      const response = await axios.post(
+        'https://id.twitch.tv/oauth2/token',
+        qs.stringify({
+          client_id: clientId,
+          client_secret: clientSecret,
+          grant_type: 'client_credentials',
+        }),
+        {
+          headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        },
+      );
+
+      const { access_token, expires_in } = response.data;
+      
+      // TTL = expiração menos 5 minutos de margem de segurança (em ms)
+      const ttl = (expires_in - 300) * 1000;
+      
+      await this.cacheManager.set(this.TOKEN_KEY, access_token, ttl);
+      
+      this.logger.log(`New token fetched. Expires in ${expires_in} seconds.`);
+      return access_token;
+    } catch (error: any) {
+      this.logger.error(`Failed to fetch Twitch token: ${error.message}`);
+      throw error;
+    }
+  }
+}

apps/api/src/cache/cache.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { EmoteCacheService } from './emote-cache.service';
+import { AuthModule } from '../auth/auth.module';
+
+@Module({
+  imports: [AuthModule],
+  providers: [EmoteCacheService],
+  exports: [EmoteCacheService],
+})
+export class CacheExtModule {}

apps/api/src/cache/emote-cache.service.ts

@@ -0,0 +1,124 @@
+import { Injectable, Logger, Inject } from '@nestjs/common';
+import { CACHE_MANAGER } from '@nestjs/cache-manager';
+import { Cache } from 'cache-manager';
+import { TokenManagerService } from '../auth/token-manager.service';
+import { ConfigService } from '@nestjs/config';
+import axios from 'axios';
+import qs from 'qs';
+
+export interface ChannelAssets {
+  globalBadges: any;
+  channelBadges: any;
+  bttvEmotes: any[];
+  ffzEmotes: any[];
+}
+
+@Injectable()
+export class EmoteCacheService {
+  private readonly logger = new Logger(EmoteCacheService.name);
+  private readonly ASSETS_TTL_MS = 3600 * 1000; // 1 Hora em milisegundos
+
+  constructor(
+    @Inject(CACHE_MANAGER) private cacheManager: Cache,
+    private tokenManager: TokenManagerService,
+    private configService: ConfigService,
+  ) {}
+
+  private async axiosGet(url: string, params: any = {}) {
+    const token = await this.tokenManager.getToken();
+    const clientId = this.configService.get<string>('TWITCH_CLIENT_ID');
+
+    return axios({
+      method: 'GET',
+      url: Object.keys(params).length ? `${url}?${qs.stringify(params)}` : url,
+      headers: {
+        'Client-ID': clientId,
+        Authorization: `Bearer ${token}`,
+      },
+    });
+  }
+
+  private async getChannelID(channelName: string): Promise<string | null> {
+    try {
+      const res = await this.axiosGet('https://api.twitch.tv/helix/users', { login: channelName });
+      return res.data?.data?.[0]?.id || null;
+    } catch (error: any) {
+      this.logger.error(`Error fetching channel ID for ${channelName}: ${error.message}`);
+      return null;
+    }
+  }
+
+  async getChannelAssets(channelName: string): Promise<ChannelAssets | null> {
+    const cacheKey = `assets:${channelName.toLowerCase()}`;
+    
+    // Tenta buscar no Redis primeiro
+    const cached = await this.cacheManager.get<ChannelAssets>(cacheKey);
+    if (cached) {
+      this.logger.log(`CACHE HIT: Loaded assets for ${channelName} from Redis.`);
+      return cached;
+    }
+
+    this.logger.log(`CACHE MISS: Fetching external API assets for ${channelName}...`);
+    
+    const channelId = await this.getChannelID(channelName);
+    if (!channelId) {
+      this.logger.warn(`Could not resolve channel ID for ${channelName}`);
+      return null;
+    }
+
+    try {
+      const [
+        globalBadgesRes,
+        channelBadgesRes,
+        bttvChannelRes,
+        bttvGlobalRes,
+        ffzChannelRes,
+        ffzGlobalRes
+      ] = await Promise.allSettled([
+        this.axiosGet('https://api.twitch.tv/helix/chat/badges/global'),
+        this.axiosGet('https://api.twitch.tv/helix/chat/badges', { broadcaster_id: channelId }),
+        axios.get(`https://api.betterttv.net/3/cached/users/twitch/${channelId}`),
+        axios.get(`https://api.betterttv.net/3/cached/emotes/global`),
+        axios.get(`https://api.frankerfacez.com/v1/room/id/${channelId}`),
+        axios.get(`https://api.frankerfacez.com/v1/set/global`),
+      ]);
+
+      const globalBadges = globalBadgesRes.status === 'fulfilled' ? globalBadgesRes.value.data : null;
+      const channelBadges = channelBadgesRes.status === 'fulfilled' ? channelBadgesRes.value.data : null;
+      
+      const bttvEmotes: any[] = [];
+      if (bttvChannelRes.status === 'fulfilled') {
+        bttvEmotes.push(...(bttvChannelRes.value.data.channelEmotes || []));
+        bttvEmotes.push(...(bttvChannelRes.value.data.sharedEmotes || []));
+      }
+      if (bttvGlobalRes.status === 'fulfilled') {
+        bttvEmotes.push(...(bttvGlobalRes.value.data || []));
+      }
+
+      const ffzEmotes: any[] = [];
+      if (ffzChannelRes.status === 'fulfilled') {
+        const sets = ffzChannelRes.value.data.sets;
+        const setKey = Object.keys(sets)[0];
+        if (setKey) ffzEmotes.push(...sets[setKey].emoticons);
+      }
+      if (ffzGlobalRes.status === 'fulfilled') {
+        ffzEmotes.push(...(ffzGlobalRes.value.data.sets['3']?.emoticons || []));
+      }
+
+      const payload: ChannelAssets = {
+        globalBadges,
+        channelBadges,
+        bttvEmotes,
+        ffzEmotes,
+      };
+
+      // Salva no Redis com TTL de 1 Hora
+      await this.cacheManager.set(cacheKey, payload, this.ASSETS_TTL_MS);
+
+      return payload;
+    } catch (error: any) {
+      this.logger.error(`Error resolving promises for assets: ${error.message}`);
+      return null;
+    }
+  }
+}

apps/api/src/controllers/assets.controller.ts

@@ -0,0 +1,16 @@
+import { Controller, Get, Param } from '@nestjs/common';
+import { EmoteCacheService } from '../cache/emote-cache.service';
+
+@Controller('api/assets')
+export class AssetsController {
+  constructor(private readonly emoteCache: EmoteCacheService) {}
+
+  @Get(':channel')
+  async getChannelAssets(@Param('channel') channel: string) {
+    const assets = await this.emoteCache.getChannelAssets(channel);
+    if (!assets) {
+      return { error: 'Failed to fetch assets for channel' };
+    }
+    return assets;
+  }
+}