# Contributing to Let's Chat

## Přehled

Vítejte v příspěvcích k Let's Chat! Tento dokument obsahuje všechny potřebné informace pro efektivní přispívání do projektu.

**Rychlé odkazy:** `docs/REQUIREMENTS.md` (funkční zadání), `doc/design/` (UI), `docs/DATAMODEL.md` (data), `docs/GITHUB_INSTRUCTIONS.md` (workflow), `docs/DEV-ONBOARDING.md` (lokální setup).

## Zásady přispívání

### Senior Developer Mindset
- **Architektura-first**: Před implementací navrhni řešení, zvaž alternativy
- **Kvalita před rychlostí**: Kód musí být udržitelný, testovatelný, dokumentovaný
- **Code review jako standard**: Každý PR musí projít review od senior developera

### Best Practices
- **SOLID principles**: Single responsibility, Open/closed, Liskov substitution, Interface segregation, Dependency inversion
- **DRY (Don't Repeat Yourself)**: Žádné duplicity kódu, konfigurací nebo instrukcí
- **KISS (Keep It Simple, Stupid)**: Jednoduchá řešení pro komplexní problémy
- **Clean Code**: Srozumitelné názvy, malé funkce, dobré komentáře
- **Alignment**: Každá změna musí odpovídat `docs/REQUIREMENTS.md`, `doc/design/` a `docs/DATAMODEL.md`.

### Technické standardy
- **TypeScript**: Strict mode, žádné `any`, comprehensive types
- **Testing**: Unit testy pro všechnu business logiku, integration testy pro API
- **Performance**: Optimalizace queries, lazy loading, code splitting
- **Security**: Input validation, SQL injection prevention, XSS protection

## Vývojový workflow

### 1. Příprava
```bash
# Fork repository
# Clone your fork
git clone https://github.com/your-username/letschat2.git
cd letschat2

# Install dependencies
npm ci

# Setup local database (optional)
npm run db:local:init
```

### 2. Vývoj
```bash
# Create feature branch
git checkout -b feature/your-feature-name

# Run development server
npm run dev

# Run tests continuously
npm run test -- --watch
```

### 3. Testování
```bash
# Run all tests
npm test

# Run with coverage
npm test -- --coverage

# Run linting
npm run lint

# Run build
npm run build
```

### 4. Commit a Push
```bash
# Add changes
git add .

# Commit with conventional format
git commit -m "feat: add user authentication"

# Push to your fork
git push origin feature/your-feature-name
```

### 5. Pull Request
- Vytvoř PR z vaší feature branche do `master`
- Vyplň PR template kompletně
- Požádej o review od senior developera
- Adresuj všechny code review komentáře

## Code Standards

### TypeScript
```typescript
// ✅ Good
interface User {
  id: string;
  email: string;
  createdAt: Date;
}

function createUser(data: CreateUserInput): Promise<User> {
  // Implementation
}

// ❌ Bad
function createUser(data: any): any {
  // Implementation
}
```

### React Components
```tsx
// ✅ Good
interface ButtonProps {
  children: React.ReactNode;
  variant?: 'primary' | 'secondary';
  onClick: () => void;
}

export function Button({ children, variant = 'primary', onClick }: ButtonProps) {
  return (
    <button
      className={clsx('btn', `btn-${variant}`)}
      onClick={onClick}
    >
      {children}
    </button>
  );
}

// ❌ Bad
export function Button({ children, ...props }) {
  return <button {...props}>{children}</button>;
}
```

### API Routes
```typescript
// ✅ Good
import { NextRequest, NextResponse } from 'next/server';
import { z } from 'zod';

const schema = z.object({
  email: z.string().email(),
  password: z.string().min(8),
});

export async function POST(request: NextRequest) {
  try {
    const body = await request.json();
    const validated = schema.parse(body);
    
    // Business logic
    const result = await createUser(validated);
    
    return NextResponse.json(result);
  } catch (error) {
    return NextResponse.json(
      { error: 'Invalid input' },
      { status: 400 }
    );
  }
}

// ❌ Bad
export async function POST(request: NextRequest) {
  const body = await request.json();
  const user = await createUser(body);
  return NextResponse.json(user);
}
```

### Testování
```typescript
// ✅ Good
import { describe, it, expect, vi } from 'vitest';

describe('createUser', () => {
  it('should create user with valid data', async () => {
    const mockUser = { id: '1', email: 'test@example.com' };
    vi.mocked(createUserInDb).mockResolvedValue(mockUser);
    
    const result = await createUser({
      email: 'test@example.com',
      password: 'password123',
    });
    
    expect(result).toEqual(mockUser);
    expect(createUserInDb).toHaveBeenCalledWith({
      email: 'test@example.com',
      passwordHash: expect.any(String),
    });
  });
});

// ❌ Bad
describe('createUser', () => {
  it('works', async () => {
    const result = await createUser({ email: 'test' });
    expect(result).toBeDefined();
  });
});
```

## Architektura

### File Structure
```
src/
├── app/                 # Next.js app router
│   ├── api/            # API routes
│   ├── (auth)/         # Auth pages
│   └── (dashboard)/    # Protected pages
├── components/         # Reusable components
│   ├── ui/            # Base UI components
│   ├── forms/         # Form components
│   └── layout/        # Layout components
├── lib/               # Business logic
│   ├── supabase/      # Supabase utilities
│   ├── validations/   # Zod schemas
│   └── utils/         # Helper functions
├── hooks/             # Custom React hooks
├── types/             # TypeScript definitions
└── db/                # Database schemas
```

### State Management
- **Local state**: React useState/useReducer
- **Server state**: SWR/React Query (plánováno)
- **Global state**: Zustand stores
- **Form state**: React Hook Form

### Error Handling
```typescript
// ✅ Good
try {
  const result = await riskyOperation();
  return { success: true, data: result };
} catch (error) {
  console.error('Operation failed:', error);
  return { success: false, error: error.message };
}

// ❌ Bad
const result = await riskyOperation();
return result;
```

## Performance Guidelines

### Frontend
- Používej React.memo pro expensive komponenty
- Implementuj lazy loading pro routes a komponenty
- Optimalizuj images s Next.js Image component
- Minimalizuj re-renders s useMemo/useCallback

### Backend
- Používej database indexes na časté queries
- Implementuj pagination pro velké datasets
- Cache expensive operations
- Používej connection pooling

### Bundle Size
- Monitoruj bundle size s `npm run build`
- Používej dynamic imports pro code splitting
- Tree-shake unused dependencies
- Optimalizuj third-party libraries

## Security Checklist

- [ ] Input validation na všech API endpoints
- [ ] SQL injection prevention s parameterized queries
- [ ] XSS protection s proper escaping
- [ ] CSRF protection na state-changing operations
- [ ] Rate limiting na sensitive endpoints
- [ ] Proper error messages (bez sensitive info)
- [ ] Secure headers (CSP, HSTS, etc.)
- [ ] Dependency vulnerability scanning

## Code Review Checklist

### Must-haves
- [ ] TypeScript strict mode bez chyb
- [ ] Unit testy pro business logiku
- [ ] ESLint bez warnings/errors
- [ ] Build passes
- [ ] Dokumentace aktualizována

### Should-haves
- [ ] Performance optimalizace
- [ ] Accessibility compliance
- [ ] Mobile responsiveness
- [ ] Error boundaries
- [ ] Loading states

### Nice-to-haves
- [ ] Integration testy
- [ ] E2E testy
- [ ] Performance benchmarks
- [ ] Bundle size monitoring

## Kontakt

Máte otázky? Kontaktujte maintainer team přes GitHub Issues nebo Discussions.