Clean Architecture — vrstvy

Každá vrstva závisí jen na vrstvách níže. Byznys logika nezávisí na frameworku, DB ani UI.

// Vrstvy (od centra ven):
// 1. Entities — core byznys objekty a pravidla
// 2. Use Cases — aplikační logika (co aplikace dělá)
// 3. Interface Adapters — controllers, presenters, gateways
// 4. Frameworks & Drivers — Express, React, Prisma, DB

// Dependency rule: závislosti VŽDY směrem dovnitř

// src/domain/entities/Product.ts (žádné závislosti!)
export class Product {
  constructor(
    public readonly id: number,
    public readonly nazev: string,
    private _cena: number,
  ) {}

  get cena() { return this._cena; }

  applyDiscount(pct: number): void {
    if (pct < 0 || pct > 100) throw new Error('Invalid discount');
    this._cena = this._cena * (1 - pct / 100);
  }
}

// src/application/usecases/CreateProduct.ts
export class CreateProductUseCase {
  constructor(private repo: IProductRepository) {} // interface!

  async execute(dto: CreateProductDto): Promise<Product> {
    const exists = await this.repo.findBySlug(dto.slug);
    if (exists) throw new Error('Slug already taken');
    const product = new Product(0, dto.nazev, dto.cena);
    return this.repo.save(product);
  }
}

// src/infrastructure/ProductRepository.ts (Prisma implementace)
export class PrismaProductRepository implements IProductRepository {
  async save(product: Product) {
    return prisma.product.create({ data: { ...product } });
  }
}copy

SOLID principy v praxi

• S — Single Responsibility: Třída/funkce má jednu zodpovědnost. ProductService neparsuje CSV a nezasílá emaily.
• O — Open/Closed: Otevřeno pro rozšíření, zavřeno pro modifikaci. Přidejte novou platební metodu bez změny existujícího kódu.
• L — Liskov Substitution: Podtypy nahradí rodičovský typ bez chyb. Každá implementace IRepository funguje zaměnitelně.
• I — Interface Segregation: Malá specifická interface > jedno velké. IProductReader, IProductWriter místo IProductRepository s 15 metodami.
• D — Dependency Inversion: Závislost na abstrakci, ne implementaci. constructor(private repo: IRepo) ne new PrismaRepo().

Repository & Service patterns

// Repository — abstrakce nad datovou vrstvou
interface IUserRepository {
  findById(id: number): Promise<User | null>;
  findByEmail(email: string): Promise<User | null>;
  save(user: User): Promise<User>;
  delete(id: number): Promise<void>;
}

// Service — orchestrace use cases
class AuthService {
  constructor(
    private users: IUserRepository,    // abstrakce!
    private tokens: ITokenService,
    private email: IEmailService,
  ) {}

  async login(email: string, password: string) {
    const user = await this.users.findByEmail(email);
    if (!user || !await bcrypt.compare(password, user.password))
      throw new UnauthorizedError();
    return this.tokens.sign({ userId: user.id });
  }
}copy

Docker produkční best practices

# Multi-stage Dockerfile — malý produkční image
FROM node:20-alpine AS deps
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production

FROM node:20-alpine AS builder
WORKDIR /app
COPY . .
COPY --from=deps /app/node_modules ./node_modules
RUN npm run build

FROM node:20-alpine AS production
WORKDIR /app
ENV NODE_ENV=production
# Bezpečnost: spustit jako non-root user
RUN addgroup -S appgroup && adduser -S appuser -G appgroup
USER appuser
COPY --from=builder --chown=appuser:appgroup /app/dist ./dist
COPY --from=deps    --chown=appuser:appgroup /app/node_modules ./node_modules
EXPOSE 4000
CMD ["node", "dist/server.js"]

# docker-compose.prod.yml
version: '3.8'
services:
  app:
    build: .
    ports: ["4000:4000"]
    environment:
      - DATABASE_URL=${DATABASE_URL}
      - JWT_SECRET=${JWT_SECRET}
    depends_on:
      db: { condition: service_healthy }
    restart: unless-stopped

  db:
    image: postgres:16-alpine
    volumes: [db_data:/var/lib/postgresql/data]
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 10s
      retries: 5

  nginx:
    image: nginx:alpine
    ports: ["80:80", "443:443"]
    volumes: [./nginx.conf:/etc/nginx/nginx.conf]

volumes: { db_data: }copy

Monitoring — Sentry + structured logging

// Sentry — error tracking
import * as Sentry from '@sentry/node';
Sentry.init({
  dsn: process.env.SENTRY_DSN,
  environment: process.env.NODE_ENV,
  tracesSampleRate: 0.1, // 10% transakcí
});
app.use(Sentry.Handlers.requestHandler());
app.use(Sentry.Handlers.errorHandler()); // musí být za routes

// Structured logging (pino)
import pino from 'pino';
const logger = pino({
  level: process.env.LOG_LEVEL || 'info',
  formatters: { level: (label) => ({ level: label }) },
});

// Log jako JSON pro log aggregátory (Datadog, Loki)
logger.info({ userId: 42, action: 'login', ip: req.ip }, 'User logged in');
logger.error({ err, orderId: order.id }, 'Order creation failed');

// Health check endpoint
app.get('/health', async (req, res) => {
  const dbOk = await checkDb();
  const status = dbOk ? 200 : 503;
  res.status(status).json({
    status: dbOk ? 'ok' : 'degraded',
    uptime: process.uptime(),
    timestamp: new Date().toISOString(),
  });
});copy

Monolith vs Mikroservisy

Začněte s monolitem. Přejděte na mikroservisy jen když máte konkrétní problém, který monolith nevyřeší.

• Monolith: Jednoduchý vývoj, deploy, debugging. Dostatečný pro 99 % aplikací. Škáluje vertikálně.
• Mikroservisy: Nezávislý deploy, škálování per service, technologická svoboda. Ale: distribuovaná komplexita, network latence, distributed transactions.
• Pravidlo: Nejdřív modular monolith (čistě oddělené moduly v jednom deploymentu). Mikroservisy až když team a škálovací potřeby to vyžadují.

Message Queue — async komunikace

// RabbitMQ / BullMQ pro asynchronní úlohy
import Queue from 'bull';

// Producer — přidat úlohu do fronty
const emailQueue = new Queue('emails', { redis: process.env.REDIS_URL });

await emailQueue.add('welcome', {
  to:      user.email,
  subject: 'Vítejte v aplikaci',
  userId:  user.id,
}, {
  attempts: 3,          // 3 pokusy při selhání
  backoff:  { type: 'exponential', delay: 2000 },
});

// Consumer — zpracovat úlohy
emailQueue.process('welcome', async (job) => {
  const { to, subject, userId } = job.data;
  await sendEmail({ to, subject, template: 'welcome', userId });
  await updateUserEmailSent(userId);
});

// Event-driven architektura
// Services komunikují přes events, ne přímými HTTP voláními
// OrderService → publish('order.created', order)
// EmailService → subscribe('order.created') → pošle potvrzení
// InventoryService → subscribe('order.created') → sníží sklad

// Výhoda: loose coupling, service neví o ostatníchcopy

📊 Skill Tree — co jste se naučili

🏅 Sbírka odznaků

🗺️ Co dál — senior level