<?php
use Psr\Http\Message\ResponseInterface as Response;
use Psr\Http\Message\ServerRequestInterface as Request;
use Slim\Factory\AppFactory;

require __DIR__ . '/vendor/autoload.php';

$app = AppFactory::create();

// 간단한 JSON API 라우트 정의
$app->get('/api/hello', function (Request $request, Response $response, $args) {
    $data = [
        "message" => "Hello from Slim Framework!",
        "status" => 200
    ];
    $response->getBody()->write(json_encode($data, JSON_PRETTY_PRINT));
    return $response->withHeader('Content-Type', 'application/json');
});

$app->run();
?>

{
  "message": "Hello from Slim Framework!",
  "status": 200
}

$ mkdir slim-app
$ cd slim-app
$ composer require slim/slim:"4.*"
$ composer require nyholm/psr7 nyholm/psr7-server

<?php
use Psr\Http\Message\ResponseInterface as Response;
use Psr\Http\Message\ServerRequestInterface as Request;
use Slim\Factory\AppFactory;

// 1. Composer Autoloader 불러오기
require __DIR__ . '/vendor/autoload.php';

// 2. Slim 앱 인스턴스 생성
$app = AppFactory::create();

// 3. 라우팅 정의 (GET /hello/{name})
$app->get('/hello/{name}', function (Request $request, Response $response, array $args) {
    $name = $args['name'];
    $data = array('message' => "Hello, $name!");
    
    // 배열을 JSON 문자열로 변환하여 응답 본문에 작성
    $response->getBody()->write(json_encode($data, JSON_PRETTY_PRINT));
    
    // JSON Content-Type 헤더와 함께 200 OK 응답 반환
    return $response
            ->withHeader('Content-Type', 'application/json')
            ->withStatus(200);
});

// 4. 앱 실행
$app->run();
?>

{
  "message": "Hello, Developer!"
}

$ composer require vlucas/phpdotenv

DB_HOST=127.0.0.1
DB_PORT=3306
DB_NAME=minstudio_db
DB_USER=root
DB_PASS=super_secret_password
API_KEY=sk_live_123456789

<?php
require __DIR__ . '/vendor/autoload.php';

// Dotenv 라이브러리를 통해 현재 디렉토리의 .env 파일을 불러옴
$dotenv = Dotenv\Dotenv::createImmutable(__DIR__);
$dotenv->load();

// 하드코딩 없이 안전하게 환경 변수 접근
$db_host = $_ENV['DB_HOST'];
$db_user = $_ENV['DB_USER'];
$api_key = $_ENV['API_KEY'];

echo "DB Host: " . $db_host . "\n";
echo "DB User: " . $db_user . "\n";
echo "API Key Length: " . strlen($api_key) . " bytes\n";
echo "보안 설정 로드 완료!";
?>

<?php
use Psr\Http\Message\ResponseInterface as Response;
use Psr\Http\Message\ServerRequestInterface as Request;

$app->post('/api/users', function (Request $request, Response $response) {
    // 1. 요청 데이터 파싱 (JSON 또는 Form Data)
    $data = $request->getParsedBody();
    
    // 2. 응답 페이로드 생성
    $payload = json_encode([
        'status' => 'success',
        'message' => "{$data['name']}님이 등록되었습니다."
    ], JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT);

    // 3. 바디에 기록하고 헤더 및 상태코드 설정
    $response->getBody()->write($payload);
    
    return $response
            ->withHeader('Content-Type', 'application/json')
            ->withStatus(201);
});
?>

{
  "status": "success",
  "message": "김개발님이 등록되었습니다."
}

<?php
// 단일 파라미터 예: /users/123 으로 접속 시
$app->get('/users/{id}', function ($request, $response, array $args) {
    $userId = $args['id']; // "123"
    $response->getBody()->write("User ID: " . $userId);
    return $response;
});

// 다중 파라미터 예: /posts/2026/05
$app->get('/posts/{year}/{month}', function ($request, $response, $args) {
    $year = $args['year'];
    $month = $args['month'];
    $response->getBody()->write("Archive: {$year}년 {$month}월");
    return $response;
});
?>

<?php
use Slim\Routing\RouteCollectorProxy;

$app->group('/api/v1', function (RouteCollectorProxy $group) {
    // 실제 경로는: GET /api/v1/users
    $group->get('/users', function ($request, $response, $args) {
        $response->getBody()->write("유저 목록 반환");
        return $response;
    });

    // 실제 경로는: GET /api/v1/users/{id}
    $group->get('/users/{id}', function ($request, $response, $args) {
        $userId = $args['id'];
        $response->getBody()->write("특정 유저 정보 반환 (ID: $userId)");
        return $response;
    });
});
?>

특정 유저 정보 반환 (ID: 4028)

<?php
use Psr\Http\Message\ServerRequestInterface as Request;
use Psr\Http\Server\RequestHandlerInterface as RequestHandler;
use Slim\Psr7\Response;

// 1. 미들웨어 클로저 정의
$authMiddleware = function (Request $request, RequestHandler $handler) {
    // 요청 검문: 헤더에 올바른 토큰이 있는지 확인
    $token = $request->getHeaderLine('Authorization');
    
    if ($token !== 'Bearer secret-token-123') {
        // 검문 실패: 다음 계층으로 넘기지 않고 즉시 에러 응답 반환! (요청 차단)
        $response = new Response();
        $response->getBody()->write(json_encode(['error' => '인증 실패']));
        return $response->withStatus(401)->withHeader('Content-Type', 'application/json');
    }
    
    // 검문 통과: 다음 미들웨어나 최종 애플리케이션 로직으로 진행
    $response = $handler->handle($request);
    
    // 최종 응답을 클라이언트에 보내기 전, 헤더 추가 등의 후처리 가능
    return $response->withHeader('X-Middleware-Passed', 'true');
};

// 2. 미들웨어 적용 (특정 라우트에만 적용)
$app->get('/api/secure-data', function ($request, $response) {
    $response->getBody()->write("보안 데이터에 접근 성공!");
    return $response;
})->add($authMiddleware); // 여기에 미들웨어 장착
?>

보안 데이터에 접근 성공!

<?php
use Respect\Validation\Validator as v;

// 1. 검증 규칙 객체 생성
$usernameValidator = v::alnum()->noWhitespace()->length(4, 15);
$emailValidator = v::email();

// 2. 단일 필드 검증 실행
if (!$usernameValidator->validate($data['username'])) {
    return respondWithError($response, '유저명은 4~15자의 영문/숫자여야 합니다.');
}
?>

<?php
use Respect\Validation\Validator as v;
use Respect\Validation\Exceptions\NestedValidationException;

$app->post('/register', function ($request, $response) {
    $data = $request->getParsedBody();

    // 폼 전체 구조에 대한 규칙 정의
    $formValidator = v::attribute('username', v::stringType()->length(3, 15))
                      ->attribute('email', v::email())
                      ->attribute('age', v::intVal()->min(18));

    try {
        // 객체 전체를 한 번에 검증 시도
        $formValidator->assert((object)$data);
        
        $response->getBody()->write(json_encode(["message" => "검증 통과! 가입 진행..."]));
        return $response->withStatus(200);

    } catch (NestedValidationException $e) {
        // 검증 실패 시: 중첩된 에러 메시지들을 배열 형태로 추출
        $errors = $e->getMessages();
        
        $response->getBody()->write(json_encode([
            "error" => "입력 데이터 형식이 잘못되었습니다.",
            "details" => $errors
        ], JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT));
        
        return $response->withStatus(400)->withHeader('Content-Type', 'application/json');
    }
});
?>

{
  "error": "입력 데이터 형식이 잘못되었습니다.",
  "details": {
    "username": "username must have a length between 3 and 15",
    "email": "email must be a valid email address",
    "age": "age must be greater than or equal to 18"
  }
}

<?php
use Monolog\Logger;
use Monolog\Handler\StreamHandler;

$container->set('logger', function () {
    // 1. "app" 이라는 이름의 채널을 가진 Logger 인스턴스 생성
    $logger = new Logger('app');
    
    // 2. 로그를 기록할 파일 경로 설정 (일자별 분리도 가능)
    // 두 번째 인자는 최소 로그 레벨입니다. (DEBUG 이상 모두 기록)
    $fileHandler = new StreamHandler(__DIR__ . '/../logs/app.log', Logger::DEBUG);
    
    // 3. 핸들러 장착
    $logger->pushHandler($fileHandler);
    
    return $logger;
});
?>

<?php
$app->post('/payment', function ($request, $response) {
    // 컨테이너에서 로거 꺼내기
    $logger = $this->get('logger');
    $data = $request->getParsedBody();

    try {
        $logger->info("결제 트랜잭션 시작", ['user_id' => $data['user_id']]);
        
        // 결제 로직 수행...
        
        $logger->info("결제 승인 완료", ['amount' => $data['amount'], 'pg' => 'Toss']);
        return $response->withStatus(200);
        
    } catch (Exception $e) {
        // 오류 발생 시 스택 트레이스 정보와 함께 ERROR 로그 기록
        $logger->error("결제 실패: " . $e->getMessage(), ['trace' => $e->getTraceAsString()]);
        return $response->withStatus(500);
    }
});
?>

<?php
use Slim\Views\Twig;
use Slim\Views\TwigMiddleware;

// 1. DI 컨테이너에 Twig 뷰 엔진 등록 (.twig 파일들이 위치할 폴더 경로 지정)
$container->set('view', function() {
    return Twig::create(__DIR__ . '/../templates', ['cache' => false]);
});

$app = AppFactory::createFromContainer($container);

// 2. 뷰 안에서 Slim 라우팅 헬퍼 함수(url_for 등)를 쓰기 위해 미들웨어 장착
$app->add(TwigMiddleware::createFromContainer($app));
?>

<?php
$app->get('/profile/{name}', function ($request, $response, $args) {
    // 컨테이너에서 Twig 인스턴스 꺼내기
    $view = $this->get('view');
    
    // 주입할 데이터 배열
    $userData = [
        'name' => $args['name'],
        'role' => 'Administrator',
        'skills' => ['PHP', 'Slim Framework', 'Twig']
    ];
    
    // profile.twig 템플릿 파일에 $userData 변수를 'user' 라는 키값으로 주입하여 렌더링 반환
    return $view->render($response, 'profile.twig', ['user' => $userData]);
});
?>

<h2>반갑습니다, {{ user.name }}님!</h2>
<p>권한: {{ user.role | upper }}</p> <!-- upper 필터를 통해 대문자로 렌더링 -->

<h4>보유 기술 스택:</h4>
<ul>
{% for skill in user.skills %}
    <li>{{ skill }}</li>
{% else %}
    <li>등록된 스킬이 없습니다.</li>
{% endfor %}
</ul>

<?php
use DI\Container;
use Slim\Factory\AppFactory;

// 1. PHP-DI 컨테이너 인스턴스 생성
$container = new Container();

// 2. 수동으로 컨테이너에 객체 등록 (예: PDO DB 연결 인스턴스)
$container->set(PDO::class, function () {
    return new PDO('mysql:host=localhost;dbname=test', 'root', 'password');
});

// 3. 컨테이너를 Slim 앱에 주입
AppFactory::setContainer($container);
$app = AppFactory::create();
?>

<?php
namespace App\Controllers;
use PDO;

class UserController {
    private $db;

    // 💡 PHP-DI가 'PDO' 타입 힌트를 보고 컨테이너에서 객체를 알아서 찾아 주입(Autowiring) 해줍니다!
    public function __construct(PDO $db) {
        $this->db = $db;
    }

    // 비즈니스 로직 메서드
    public function getUser($request, $response, $args) {
        $stmt = $this->db->prepare("SELECT * FROM users WHERE id = ?");
        $stmt->execute([$args['id']]);
        
        $response->getBody()->write(json_encode($stmt->fetch()));
        return $response->withHeader('Content-Type', 'application/json');
    }
}

// index.php 에서는 클래스와 메서드를 문자열로만 연결하면 끝납니다.
$app->get('/users/{id}', '\App\Controllers\UserController:getUser');
?>

<?php
use Illuminate\Database\Capsule\Manager as Capsule;

$capsule = new Capsule;
$capsule->addConnection([
    'driver'    => 'mysql',
    'host'      => 'localhost',
    'database'  => 'minstudio_db',
    'username'  => 'root',
    'password'  => 'secret_pass',
    'charset'   => 'utf8mb4',
    'collation' => 'utf8mb4_unicode_ci',
    'prefix'    => '',
]);

// 어디서든 전역 정적(Static) 메서드로 ORM을 사용할 수 있게 설정
$capsule->setAsGlobal();
// Eloquent ORM 부팅
$capsule->bootEloquent();
?>

<?php
namespace App\Models;
use Illuminate\Database\Eloquent\Model;

class User extends Model {
    // 💡 별도의 필드 선언 없이도 DB 컬럼이 동적으로 매핑됩니다!
    // protected $table = 'my_custom_users';
    // protected $fillable = ['name', 'email']; 
}

// ----------------------------------------
// 라우트 내부 비즈니스 로직에서의 활용 예시
// ----------------------------------------
$app->get('/users', function ($request, $response) {
    // ❌ 기존 PDO 방식 (하드코딩된 SQL 문자열)
    // $stmt = $pdo->query("SELECT * FROM users WHERE active = 1 ORDER BY created_at DESC");
    // $users = $stmt->fetchAll();

    // ✅ Eloquent ORM 쿼리 빌더 방식 (직관적인 메서드 체이닝)
    $users = \App\Models\User::where('active', 1)->orderBy('created_at', 'desc')->get();
    
    // 객체 컬렉션을 JSON으로 자동 직렬화
    $response->getBody()->write($users->toJson());
    return $response->withHeader('Content-Type', 'application/json');
});
?>

<?php
use Slim\Routing\RouteCollectorProxy;

// '/users' 공통 경로를 묶는 그룹 설정
$app->group('/users', function (RouteCollectorProxy $group) {
    
    // [C] 생성: POST /users
    $group->post('', function ($request, $response) {
        $data = $request->getParsedBody();
        // DB 저장 로직 (Eloquent 등)
        return $response->withStatus(201); // 상태코드 201 Created 반환
    });

    // [R] 목록 조회: GET /users
    $group->get('', function ($request, $response) {
        $users = ["user1", "user2"];
        $response->getBody()->write(json_encode($users));
        return $response->withHeader('Content-Type', 'application/json')->withStatus(200);
    });

    // [R] 단일 조회: GET /users/{id}
    $group->get('/{id}', function ($request, $response, $args) {
        // $args['id'] 로 대상 유저 식별
        return $response->withStatus(200);
    });

    // [U] 통째로 수정: PUT /users/{id}
    $group->put('/{id}', function ($request, $response, $args) {
        return $response->withStatus(200);
    });

    // [D] 삭제: DELETE /users/{id}
    $group->delete('/{id}', function ($request, $response, $args) {
        return $response->withStatus(204); // 성공했으나 돌려줄 바디 내용이 없다는 뜻 (204 No Content)
    });
    
});
?>

<?php
$app->get('/users', function ($request, $response) {
    $data = ['id' => 1, 'name' => 'Minstudio'];
    
    // ❌ 매번 반복해야 하는 코드
    $response->getBody()->write(json_encode($data));
    return $response
            ->withHeader('Content-Type', 'application/json')
            ->withStatus(200);
});
?>

<?php
// helpers.php 에 선언해두고 전역으로 로드
function jsonResponse($response, array $data, int $status = 200) {
    // JSON_UNESCAPED_UNICODE 옵션으로 한글 깨짐 방지
    $response->getBody()->write(json_encode($data, JSON_UNESCAPED_UNICODE));
    return $response
        ->withHeader('Content-Type', 'application/json')
        ->withStatus($status);
}

// ------------------------------------
// 라우터에서의 활용 (코드가 훨씬 간결해집니다)
// ------------------------------------
$app->post('/users', function ($request, $response) {
    // DB 저장 로직 (Eloquent 등)
    $newUser = ['id' => 3, 'name' => 'Charlie'];
    
    // ✅ 단 한 줄로 JSON 응답 바디 작성 + 상태 코드 설정 완료
    return jsonResponse($response, $newUser, 201);
});
?>

<?php
use Firebase\JWT\JWT;

$app->post('/api/login', function ($request, $response) {
    $data = $request->getParsedBody();
    
    // (생략) DB에서 유저 조회 및 password_verify() 검증 수행
    // if (!$isValidUser) { return jsonResponse($response, ['error'=>'실패'], 401); }

    $secretKey  = $_ENV['JWT_SECRET']; // ⚠️ 절대 하드코딩 금지, .env에서 로드
    $issuedAt   = time();
    $expire     = $issuedAt + 3600; // 1시간 후 만료

    // Payload 데이터 구성
    $payload = [
        'iat'  => $issuedAt,
        'exp'  => $expire,
        'sub'  => 7 // 인증된 유저의 Primary Key
    ];

    // JWT 라이브러리를 통해 암호화(Encode)된 토큰 문자열 생성
    $token = JWT::encode($payload, $secretKey, 'HS256');

    return jsonResponse($response, ['token' => $token], 200);
});
?>

<?php
use Firebase\JWT\JWT;
use Firebase\JWT\Key;

$app->get('/api/profile', function ($request, $response) {
    $header = $request->getHeaderLine('Authorization');
    $token = str_replace('Bearer ', '', $header); // Bearer 키워드 분리

    if (empty($token)) {
        return jsonResponse($response, ['error' => '토큰이 누락되었습니다.'], 401);
    }

    try {
        $secretKey = $_ENV['JWT_SECRET'];
        
        // 💡 토큰 해독 시도: 만약 위조되었거나 만료되었다면 여기서 즉시 Exception 발생!
        $decoded = JWT::decode($token, new Key($secretKey, 'HS256'));
        
        $userId = $decoded->sub; // 토큰에 담아뒀던 유저 ID 꺼내기
        
        // (DB 조회 등 비즈니스 로직 수행)
        return jsonResponse($response, ['user_id' => $userId, 'name' => 'John'], 200);

    } catch (\Exception $e) {
        // 해독 실패 (만료, 변조 등)
        return jsonResponse($response, ['error' => '유효하지 않은 토큰입니다.'], 401);
    }
});
?>

<?php
// 1. 패키지 설치: composer require slim/csrf
use Slim\Csrf\Guard;

// 2. 세션 시작 (토큰을 서버 메모리에 저장하기 위해 필수)
session_start();

// 3. CSRF Guard 객체 생성 및 전역 미들웨어로 앱에 장착
$responseFactory = $app->getResponseFactory();
$csrf = new Guard($responseFactory);
$app->add($csrf);

// ----------------------------------------
// GET 라우트: CSRF 토큰을 생성하여 뷰(View)에 내려줌
// ----------------------------------------
$app->get('/form', function ($request, $response) use ($csrf) {
    // 보안 토큰 이름과 실제 난수값 획득
    $nameKey = $csrf->getTokenNameKey();
    $valueKey = $csrf->getTokenValueKey();
    $name = $request->getAttribute($nameKey);
    $value = $request->getAttribute($valueKey);

    // HTML Form 안에 hidden 필드로 토큰을 몰래 심어둡니다.
    $html = "
      <form method='POST' action='/submit'>
         <input type='hidden' name='$nameKey' value='$name'>
         <input type='hidden' name='$valueKey' value='$value'>
         <input type='text' name='message'>
         <button type='submit'>보안 전송</button>
      </form>";
      
    $response->getBody()->write($html);
    return $response;
});

// ----------------------------------------
// POST 라우트: 폼 처리 (미들웨어가 방어벽 역할을 먼저 수행함)
// ----------------------------------------
$app->post('/submit', function ($request, $response) {
    // 💡 이 비즈니스 로직까지 도달했다는 것은 CSRF 토큰 검사를 무사히 통과했다는 뜻입니다!
    $data = $request->getParsedBody();
    
    // XSS 방지를 위한 데이터 Sanitization 적용
    $cleanMessage = htmlspecialchars($data['message'] ?? '', ENT_QUOTES, 'UTF-8');
    
    // DB 저장...
    $response->getBody()->write("안전하게 처리 및 저장됨: " . $cleanMessage);
    return $response;
});
?>

<?php
use Psr\Http\Message\ServerRequestInterface as Request;
use Psr\Http\Server\RequestHandlerInterface as RequestHandler;
use Psr\Http\Message\ResponseInterface as Response;
use Psr\Http\Server\MiddlewareInterface;
use Slim\Psr7\Response as SlimResponse;

// PSR-15 표준을 완벽히 준수하는 커스텀 미들웨어
class ApiTokenMiddleware implements MiddlewareInterface
{
    // PSR-15의 유일한 요구사항: process 메서드 구현
    public function process(Request $request, RequestHandler $handler): Response
    {
        // 1. 요청(Request) 검사 (안쪽 계층으로 들어가기 전)
        $token = $request->getHeaderLine('X-API-Key');
        
        if ($token !== 'secret_123') {
            // [검증 실패] : 다음 계층(라우터)으로 보내지 않고, 즉시 401 에러를 담아 반환 (단락 평가)
            $response = new SlimResponse();
            $response->getBody()->write('Invalid Token');
            return $response->withStatus(401);
        }

        // 2. [검증 성공] : RequestHandler를 통해 다음 미들웨어(또는 최종 코어 라우터)로 Request를 넘겨줌
        // 그리고 비즈니스 로직 처리가 모두 끝난 후 되돌아온 Response 객체를 받음
        $response = $handler->handle($request);

        // 3. 응답(Response) 가공 후 바깥 계층으로 반환 (밖으로 빠져나올 때)
        return $response->withHeader('X-Processed-By', 'ApiTokenMiddleware');
    }
}
?>