Kurs NestJS · Moduł 12: Konteneryzacja i CI/CD
PROJEKT: Kompleksowa Aplikacja Imperium Romanum
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)
- Setup projektu - konfiguracja NestJS, TypeORM, Redis
- Authentication system - JWT, refresh tokeny, role-based access
- Base entities - User, Legion, Cohort, Tribute podstawowe
- API endpoints - CRUD operations dla podstawowych encji
- Basic tests - unit testy dla serwisów
Etap 2: Funkcjonalności biznesowe (Tydzień 2)
- Campaign system - planowanie i wykonywanie kampanii
- Trading system - wymiana tributów między legionistami
- Legion management - zarządzanie legionami i umiejętnościami
- Notification system - powiadomienia w czasie rzeczywistym
- Advanced validation - complex business rules
Etap 3: Real-time i zaawansowane (Tydzień 3)
- WebSocket integration - real-time communication
- Auction system - licytacje tributów
- Analytics dashboard - statystyki i metryki
- Background jobs - przetwarzanie async zadań
- Performance optimization - caching, indexy, optymalizacje
Etap 4: Produkcja i zaawansowane (Tydzień 4)
- GraphQL implementation - alternatywne API
- Rate limiting - ochrona przed spam
- Monitoring - health checks, metrics, alerting
- Deployment - Docker, CI/CD, environment management
- 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 tributTo 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?