Zbuduj bezpieczne API użytkowników od zera.

Użytkownik klika „Zaloguj” w aplikacji
        ↓
Frontend wysyła POST /auth/login z e-mailem i hasłem
        ↓
Controller odbiera HTTP request i przekazuje dane dalej
        ↓
Service sprawdza hasło i wykonuje logikę logowania
        ↓
Prisma odczytuje użytkownika z PostgreSQL
        ↓
Backend zwraca JSON z użytkownikiem i tokenami

Controller: „Dostałem POST /auth/login. Oto dane z body.”
Service:    „Znajdę użytkownika, sprawdzę hasło, wydam tokeny.”
Prisma:     „Wykonam zapytanie do PostgreSQL.”
Database:   „Zwracam zapisany rekord użytkownika.”

1. Potrzeba: „Zalogowany użytkownik ma zobaczyć swój profil”.
2. Dane: potrzebuję User { id, email, name, bio }.
3. Umowa API: GET /users/:id albo GET /auth/me?
4. Uprawnienia: kto może to zobaczyć? Czy endpoint wymaga JWT?
5. DTO: jakie dane przyjmuję i jak je waliduję?
6. Service: jakie reguły wykonuję i jakie błędy zwracam?
7. Baza: czy model już zawiera wymagane dane i indeksy?
8. Testy: sukces, brak danych, brak uprawnień, błędne dane.

// users.controller.ts — warstwa HTTP
@Get(':id')
findOne(@Param('id') id: string) {
  return this.usersService.findById(id);
}

// users.service.ts — logika i baza
async findById(id: string) {
  const user = await this.prisma.user.findUnique({ where: { id } });
  if (!user) throw new NotFoundException('User not found');
  return this.toPublicUser(user);
}

// 1. Schema: potrzebujemy opisu użytkownika
model User {
  id String @id @default(uuid())
  email String @unique
  name String?
  bio String? // nowe opcjonalne pole
}

// 2. Zmieniamy prawdziwą bazę przez migrację
npx.cmd prisma migrate dev --name add_user_bio

// 3. Odświeżamy typy klienta Prisma
npx.cmd prisma generate

# logi aplikacji
npm.cmd run start:dev

# status bazy i kontenera
docker compose ps
docker compose logs -f postgres

# wygodny podgląd danych w przeglądarce
npx.cmd prisma studio

mkdir nest-auth-api
cd nest-auth-api
npx @nestjs/cli new api
cd api

# Jeśli PowerShell blokuje npm.ps1, używaj wariantu .cmd:
npx.cmd @nestjs/cli new api

npm.cmd run start:dev
# Otwórz potem: http://localhost:3000

services:
  postgres:
    image: postgres:17
    container_name: nest-auth-postgres
    restart: unless-stopped
    environment:
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_DB: ${POSTGRES_DB}
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:

docker compose up -d
docker compose ps
docker exec -it nest-auth-postgres psql -U app_user -d app_db

npm.cmd install @prisma/client @prisma/adapter-pg pg
npm.cmd install -D prisma
npx.cmd prisma init

# .env
DATABASE_URL="postgresql://app_user:app_password@localhost:5432/app_db"
POSTGRES_USER="app_user"
POSTGRES_PASSWORD="app_password"
POSTGRES_DB="app_db"

generator client {
  provider = "prisma-client"
  output = "../generated/prisma"
  moduleFormat = "cjs"
}

datasource db { provider = "postgresql" }

model User {
  id String @id @default(uuid())
  email String @unique
  name String?
  passwordHash String
  refreshTokens RefreshToken[]
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
}

model RefreshToken {
  id String @id @default(uuid())
  tokenHash String @unique
  userId String
  user User @relation(fields: [userId], references: [id], onDelete: Cascade)
  expiresAt DateTime
  revokedAt DateTime?
  createdAt DateTime @default(now())
  @@index([userId])
}

npx.cmd nest g module prisma
npx.cmd nest g service prisma
npx.cmd nest g module users
npx.cmd nest g service users
npx.cmd nest g controller users
npx.cmd nest g module auth
npx.cmd nest g service auth
npx.cmd nest g controller auth

src/
  auth/
    dto/ login.dto.ts, register.dto.ts, refresh-token.dto.ts
    guards/ jwt-access.guard.ts
    strategies/ jwt-access.strategy.ts
    auth.controller.ts
    auth.service.ts
  common/decorators/current-user.decorator.ts
  prisma/prisma.service.ts
  users/dto/create-user.dto.ts
  users/users.service.ts

const existingUser = await this.prisma.user.findUnique({
  where: { email: dto.email },
});

if (existingUser) {
  throw new ConflictException('User with this email already exists');
}

const passwordHash = await bcrypt.hash(dto.password, 12);
const user = await this.prisma.user.create({
  data: { email: dto.email, name: dto.name, passwordHash },
});

return toPublicUser(user);

const isPasswordValid = await bcrypt.compare(
  dto.password,
  user.passwordHash,
);

if (!isPasswordValid) {
  throw new UnauthorizedException('Invalid email or password');
}

return {
  user: publicUser,
  accessToken,
  refreshToken,
};

{
  "sub": "uuid-uzytkownika",
  "email": "wiktor@example.com",
  "iat": 1780000000,
  "exp": 1780000900
}

1. POST /auth/login
   - serwer porównuje hasło przez bcrypt.compare()
   - zwraca accessToken i refreshToken

2. GET /auth/me
   Authorization: Bearer <accessToken>
   - guard sprawdza podpis i exp access tokenu
   - strategy ustawia request.user = { id, email }

3. Access token wygasł
   - API zwraca 401 Unauthorized
   - klient wywołuje POST /auth/refresh z refreshTokenem
   - API zwraca nową parę tokenów
   - klient ponawia pierwotny request

@Injectable()
export class JwtAccessStrategy extends PassportStrategy(Strategy, 'jwt-access') {
  constructor(config: ConfigService) {
    super({
      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
      secretOrKey: config.getOrThrow('JWT_ACCESS_SECRET'),
    });
  }

  validate(payload: { sub: string; email: string }) {
    return { id: payload.sub, email: payload.email };
  }
}

@UseGuards(JwtAccessGuard)
@Get('me')
me(@CurrentUser() user: AuthenticatedUser) {
  return user;
}

const refreshToken = await this.jwtService.signAsync(
  { sub: user.id, email: user.email, jti: randomUUID() },
  {
    secret: config.getOrThrow('JWT_REFRESH_SECRET'),
    expiresIn: config.getOrThrow('JWT_REFRESH_EXPIRES_IN'),
  },
);

await prisma.refreshToken.create({
  data: {
    tokenHash: await bcrypt.hash(refreshToken, 12),
    userId: user.id,
    expiresAt: refreshTokenExpiresAt,
  },
});

npm.cmd test -- --runInBand
npm.cmd run test:e2e -- --runInBand
npm.cmd exec tsc -- --noEmit --incremental false

let refreshPromise: Promise<void> | null = null;

async function ensureFreshTokens() {
  if (!refreshPromise) {
    refreshPromise = refreshTokens().finally(() => {
      refreshPromise = null;
    });
  }
  return refreshPromise;
}