Kurs NestJS · Moduł 12: Konteneryzacja i CI/CD

PROJEKT: Kompleksowa Aplikacja Imperium Romanum

8 min czytania ·
W tej lekcji6

Ave, legacie! Konsul Caesar.js powierzył Ci największe wyzwanie - stworzenie kompletnej aplikacji do zarządzania rzymskim imperium. To będzie prawdziwy test wszystkich umiejętności, które zdobyłeś podczas nauki NestJS!

Specyfikacja Projektu: Imperium Management System

Twoja aplikacja musi być kompletnym systemem zarządzania legionami rzymskimi, obsługującym:

1. System Użytkowników i Autoryzacji

  • Rejestracja i logowanie legionistów z różnymi rangami
  • JWT Authentication z refresh tokenami
  • Role-based access control (RBAC)
  • Multi-factor authentication dla konsulów

2. Zarządzanie legionami

  • Legiony - różne typy, pojemności, wyposażenie
  • Żołnierze - legionacy z umiejętnościami i historiami
  • Kampanie - wyprawy po trybuty z planowaniem tras
  • Forty - bazy operacyjne z zasobami

3. System tributów

  • Inventory management - skrzynie, tributy, artefakty
  • Trading system - wymiana między legionami
  • Auction house - licytacje rzadkich przedmiotów
  • Value tracking - śledzenie wartości w czasie

4. Komunikacja i Koordynacja

  • Real-time messaging - WebSocket communication
  • Legion announcements - ogłoszenia dla legionów
  • Battle coordination - koordynacja podczas bitew
  • Weather alerts - powiadomienia o pogodzie

5. Analytics i Raporty

  • Performance dashboards - statystyki legionów
  • Tribute reports - analizy zysków
  • Legion analytics - wydajność legionów
  • Predictive insights - AI-driven predictions

Struktura Techniczna

Core Modules

// app.module.ts
import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import { TypeOrmModule } from '@nestjs/typeorm';
import { GraphQLModule } from '@nestjs/graphql';
import { ApolloDriver, ApolloDriverConfig } from '@nestjs/apollo';
import { BullModule } from '@nestjs/bull';
import { CacheModule } from '@nestjs/cache-manager';
import { EventEmitterModule } from '@nestjs/event-emitter';

// Custom modules
import { AuthModule } from './auth/auth.module';
import { LegionModule } from './legion/legion.module';
import { LegionaryModule } from './legionary/legionary.module';
import { TributeModule } from './tribute/tribute.module';
import { CampaignModule } from './campaign/campaign.module';
import { CommunicationModule } from './communication/communication.module';
import { AnalyticsModule } from './analytics/analytics.module';
import { WebsocketModule } from './websocket/websocket.module';

// Configuration
import { databaseConfig, redisConfig, appConfig } from './config';
import { validationSchema } from './config/validation.schema';

@Module({
 imports: [
 // Configuration
 ConfigModule.forRoot({
 isGlobal: true,
 load: [databaseConfig, redisConfig, appConfig],
 validationSchema,
 }),

 // Database
 TypeOrmModule.forRootAsync({
 useFactory: (configService: ConfigService) => configService.get('database'),
 inject: [ConfigService],
 }),

 // GraphQL
 GraphQLModule.forRoot<ApolloDriverConfig>({
 driver: ApolloDriver,
 autoSchemaFile: 'schema.gql',
 subscriptions: {
 'graphql-ws': true,
 },
 context: ({ req, connection }) =>
 connection ? { req: connection.context } : { req },
 }),

 // Redis & Caching
 BullModule.forRootAsync({
 useFactory: (configService: ConfigService) => configService.get('redis'),
 inject: [ConfigService],
 }),

 CacheModule.registerAsync({
 useFactory: (configService: ConfigService) => ({
 store: 'redis',
 ...configService.get('redis'),
 ttl: 300, // 5 minutes default
 }),
 inject: [ConfigService],
 }),

 // Event system
 EventEmitterModule.forRoot(),

 // Feature modules
 AuthModule,
 LegionModule,
 LegionaryModule,
 TributeModule,
 CampaignModule,
 CommunicationModule,
 AnalyticsModule,
 WebsocketModule,
 ],
 providers: [
 // Global guards
 {
 provide: APP_GUARD,
 useClass: JwtAuthGuard,
 },
 {
 provide: APP_GUARD,
 useClass: RolesGuard,
 },
 // Global interceptors
 {
 provide: APP_INTERCEPTOR,
 useClass: LoggingInterceptor,
 },
 {
 provide: APP_INTERCEPTOR,
 useClass: TransformInterceptor,
 },
 // Global filters
 {
 provide: APP_FILTER,
 useClass: AllExceptionsFilter,
 },
 ],
})
export class AppModule {}

Advanced Features Implementation

// auth/strategies/jwt.strategy.ts
@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) {
 constructor(
 private configService: ConfigService,
 private userService: UserService,
 ) {
 super({
 jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
 ignoreExpiration: false,
 secretOrKey: configService.get<string>('jwt.secret'),
 });
 }

 async validate(payload: any) {
 const user = await this.userService.findById(payload.sub);
 if (!user || !user.isActive) {
 throw new UnauthorizedException('Legionary not found or inactive');
 }
 return user;
 }
}

// websocket/legion-communication.gateway.ts
@WebSocketGateway({
 cors: {
 origin: '*',
 },
})
export class LegionCommunicationGateway
 implements OnGatewayInit, OnGatewayConnection, OnGatewayDisconnect {

 @WebSocketServer()
 server: Server;

 private logger: Logger = new Logger('LegionCommunicationGateway');
 private legionaryConnections = new Map<string, string>(); // socketId -> legionaryId

 afterInit(server: Server) {
 this.logger.log('Legion Communication Gateway initialized');
 }

 async handleConnection(client: Socket, ...args: any[]) {
 try {
 const token = client.handshake.auth.token;
 const legionary = await this.authService.validateToken(token);

 this.legionaryConnections.set(client.id, legionary.id);
 client.join(`cohort_${legionary.cohortId}`);
 client.join(`legion_${legionary.legionId}`);

 this.server.to(`cohort_${legionary.cohortId}`).emit('legionaryJoined', {
 legionary: legionary.name,
 message: `${legionary.name} dołączył do komunikacji`,
 });

 this.logger.log(`Legionary ${legionary.name} connected to legion communication`);
 } catch (error) {
 this.logger.error('Connection failed:', error);
 client.disconnect();
 }
 }

 handleDisconnect(client: Socket) {
 const legionaryId = this.legionaryConnections.get(client.id);
 if (legionaryId) {
 this.legionaryConnections.delete(client.id);
 this.logger.log(`Legionary ${legionaryId} disconnected`);
 }
 }

 @SubscribeMessage('cohortMessage')
 handleCohortMessage(client: Socket, payload: any) {
 const legionaryId = this.legionaryConnections.get(client.id);
 const legionary = this.userService.findById(legionaryId);

 client.to(`cohort_${legionary.cohortId}`).emit('cohortMessage', {
 from: legionary.name,
 message: payload.message,
 timestamp: new Date(),
 });
 }

 @SubscribeMessage('legionAnnouncement')
 @UseGuards(WsJwtGuard, WsRolesGuard)
 @Roles('CENTURION', 'CONSUL')
 handleLegionAnnouncement(client: Socket, payload: any) {
 const legionaryId = this.legionaryConnections.get(client.id);
 const legionary = this.userService.findById(legionaryId);

 this.server.to(`legion_${legionary.legionId}`).emit('legionAnnouncement', {
 from: legionary.name,
 rank: legionary.rank,
 message: payload.message,
 priority: payload.priority || 'normal',
 timestamp: new Date(),
 });
 }
}

// analytics/services/advanced-analytics.service.ts
@Injectable()
export class AdvancedAnalyticsService {
 constructor(
 private dataSource: DataSource,
 @InjectQueue('analytics') private analyticsQueue: Queue,
 ) {}

 async generateLegionPerformanceReport(legionId: number, period: string) {
 const job = await this.analyticsQueue.add('legion-performance', {
 legionId,
 period,
 });

 return { jobId: job.id };
 }

 async getPredictiveTributeInsights(legionId: number) {
 // Machine learning predictions (przykład z TensorFlow.js)
 const historicalData = await this.getHistoricalTributeData(legionId);
 const predictions = await this.mlPredict(historicalData);

 return {
 predictedTributeValue: predictions.value,
 confidence: predictions.confidence,
 recommendedActions: predictions.actions,
 timeframe: '30 days',
 };
 }

 private async mlPredict(data: any[]) {
 // Przykład prostego ML modelu
 const values = data.map(d => d.value);
 const trend = this.calculateTrend(values);
 const seasonality = this.calculateSeasonality(data);

 return {
 value: trend.nextPrediction * seasonality.factor,
 confidence: Math.min(trend.confidence * seasonality.confidence, 0.95),
 actions: this.generateRecommendations(trend, seasonality),
 };
 }

 @Cron('0 2 * * *') // Codziennie o 2:00
 async generateDailyReports() {
 const legions = await this.getActiveLegions();

 for (const legion of legions) {
 await this.analyticsQueue.add('daily-report', {
 legionId: legion.id,
 date: new Date(),
 });
 }
 }
}

// tribute/services/auction.service.ts
@Injectable()
export class AuctionService {
 constructor(
 private auctionRepository: AuctionRepository,
 private eventEmitter: EventEmitter2,
 @InjectQueue('auction') private auctionQueue: Queue,
 ) {}

 async createAuction(tributeId: number, sellerId: number, startingPrice: number, duration: number) {
 const auction = await this.auctionRepository.create({
 tributeId,
 sellerId,
 startingPrice,
 currentPrice: startingPrice,
 endTime: new Date(Date.now() + duration * 1000),
 status: 'ACTIVE',
 });

 // Schedule auction end
 await this.auctionQueue.add(
 'end-auction',
 { auctionId: auction.id },
 { delay: duration * 1000 }
 );

 this.eventEmitter.emit('auction.created', auction);
 return auction;
 }

 async placeBid(auctionId: number, bidderId: number, amount: number) {
 const auction = await this.auctionRepository.findById(auctionId);

 if (auction.status !== 'ACTIVE' || new Date() > auction.endTime) {
 throw new BadRequestException('Auction is not active');
 }

 if (amount <= auction.currentPrice) {
 throw new BadRequestException('Bid must be higher than current price');
 }

 // Anti-sniping: extend auction if bid in last 5 minutes
 const timeLeft = auction.endTime.getTime() - Date.now();
 if (timeLeft < 5 * 60 * 1000) {
 auction.endTime = new Date(auction.endTime.getTime() + 5 * 60 * 1000);
 }

 auction.currentPrice = amount;
 auction.currentBidderId = bidderId;

 await this.auctionRepository.save(auction);

 this.eventEmitter.emit('auction.bid', {
 auctionId,
 bidderId,
 amount,
 timeLeft: Math.max(0, timeLeft),
 });

 return auction;
 }

 @OnEvent('auction.end')
 async handleAuctionEnd(auctionId: number) {
 const auction = await this.auctionRepository.findById(auctionId);

 if (auction.currentBidderId) {
 await this.transferTribute(auction.tributeId, auction.currentBidderId);
 await this.transferFunds(auction.currentBidderId, auction.sellerId, auction.currentPrice);

 auction.status = 'COMPLETED';
 auction.winnerId = auction.currentBidderId;
 } else {
 auction.status = 'NO_BIDS';
 }

 await this.auctionRepository.save(auction);
 this.eventEmitter.emit('auction.completed', auction);
 }
}

Zadania do realizacji

Etap 1: Podstawowa architektura (Tydzień 1)

  1. Setup projektu - konfiguracja NestJS, TypeORM, Redis
  2. Authentication system - JWT, refresh tokeny, role-based access
  3. Base entities - User, Legion, Cohort, Tribute podstawowe
  4. API endpoints - CRUD operations dla podstawowych encji
  5. Basic tests - unit testy dla serwisów

Etap 2: Funkcjonalności biznesowe (Tydzień 2)

  1. Campaign system - planowanie i wykonywanie kampanii
  2. Trading system - wymiana tributów między legionistami
  3. Legion management - zarządzanie legionami i umiejętnościami
  4. Notification system - powiadomienia w czasie rzeczywistym
  5. Advanced validation - complex business rules

Etap 3: Real-time i zaawansowane (Tydzień 3)

  1. WebSocket integration - real-time communication
  2. Auction system - licytacje tributów
  3. Analytics dashboard - statystyki i metryki
  4. Background jobs - przetwarzanie async zadań
  5. Performance optimization - caching, indexy, optymalizacje

Etap 4: Produkcja i zaawansowane (Tydzień 4)

  1. GraphQL implementation - alternatywne API
  2. Rate limiting - ochrona przed spam
  3. Monitoring - health checks, metrics, alerting
  4. Deployment - Docker, CI/CD, environment management
  5. Advanced security - security headers, CORS, data encryption

Kryteria oceny

Funkcjonalność (25%)

  • Wszystkie wymagane funkcje działają poprawnie
  • Kompleksowy system autoryzacji i uprawnień
  • Real-time communication między użytkownikami
  • Zaawansowane funkcje biznesowe (aukcje, misje, handel)

Jakość kodu (25%)

  • Czytelna architektura i struktura projektu
  • Właściwe użycie wzorców projektowych
  • Consistent code style i naming conventions
  • Proper error handling i validation

Performance i skalowalność (20%)

  • Optymalizacja zapytań do bazy danych
  • Effective caching strategies
  • Background job processing
  • Rate limiting i resource management

Testy (15%)

  • Comprehensive unit tests (>80% coverage)
  • Integration tests dla kluczowych flow
  • E2E tests dla głównych funkcjonalności
  • Performance tests

Dokumentacja (15%)

  • API documentation (Swagger/OpenAPI)
  • README z instrukcjami setup i deployment
  • Architecture documentation
  • Code comments gdzie potrzebne

Bonus Points

  • GraphQL subscriptions dla real-time updates
  • Machine learning predictions dla tribute values
  • Microservices architecture z message queues
  • Advanced monitoring z Prometheus/Grafana
  • Mobile app komunikująca się z API

Przykładowe endpointy API

// Legion Management
GET /api/legions # Lista legionów
POST /api/legions # Utwórz legion
GET /api/legions/:id # Szczegóły legionu
PUT /api/legions/:id # Aktualizuj legion
DELETE /api/legions/:id # Usuń legion

// Cohort Management
GET /api/cohorts # Lista kohort
POST /api/cohorts # Dodaj kohortę
GET /api/cohorts/:id # Szczegóły kohorty
PUT /api/cohorts/:id # Aktualizuj kohortę
POST /api/cohorts/:id/assign-legionaries # Przypisz legionistów
POST /api/cohorts/:id/campaigns # Utwórz kampanię

// Tribute System
GET /api/tributes # Lista tributów
POST /api/tributes # Dodaj tribut
GET /api/tributes/:id # Szczegóły tributu
PUT /api/tributes/:id/transfer # Transfer tributu
POST /api/tributes/:id/auction # Wystawienie na aukcję

// Auctions
GET /api/auctions # Aktywne aukcje
POST /api/auctions/:id/bid # Złóż ofertę
GET /api/auctions/:id/history # Historia licytacji

// Analytics
GET /api/analytics/legion/:id # Statystyki legionu
GET /api/analytics/tribute-trends # Trendy wartości tributów
GET /api/analytics/legion-performance # Wydajność legionów

// Real-time WebSocket events
cohort:message # Wiadomości w kohorcie
legion:announcement # Ogłoszenia legionu
auction:bid # Nowa oferta aukcji
campaign:update # Update kampanii
tribute:discovered # Znaleziony tribut

To największe wyzwanie w służbie Imperium Romanum! Powodzenia, legate - imperium liczy na Ciebie!

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

  1. WideoPodsumowanie modułu

Przydatne artykuły