Comprobar el flujo de datos-Diseño de arquitectura-Prototipo funcional del flujo de datos

Comprobar el flujo de datos - Diseño de arquitectura - Prototipo funcional del flujo de datos
agosto 28, 2026

Lo que estás describiendo es una excelente forma de empezar el desarrollo: primero comprobar el flujo de datos y después construir la interfaz.

Para esta primera etapa podemos hacer una guía extremadamente comprimida:

Base de datos → Modelo → Controlador → Vista Blade

Sin CSS, sin Bootstrap, sin JavaScript, sin formularios todavía.

El objetivo es únicamente comprobar:

text
BD
 ↓
Model
 ↓
Controller
 ↓
View
 ↓
mostrar datos

¿Cómo se llama esta etapa?

Lo que describes normalmente se relaciona con varias actividades de desarrollo:

  • Análisis de requisitos → qué necesita hacer el sistema.

  • Modelado de datos → qué tablas, campos y relaciones necesitamos.

  • Diseño de base de datos → estructura de las tablas.

  • Diseño de arquitectura → cómo se comunican las diferentes partes.

  • Prototipo / prueba de concepto (PoC) → comprobar rápidamente que el flujo funciona.

Para tu curso, yo lo llamaría:

Análisis y diseño previo al desarrollo

Y para este ejercicio concreto:

Prototipo funcional del flujo de datos

Es decir, antes de hacer una pantalla bonita, comprobamos que Laravel puede llevar los datos desde MySQL hasta Blade.

Guía mínima — CRUD Pasteles

0. Inicializar Git (control de versiones)

Antes de empezar a codificar, es buena práctica inicializar un repositorio Git para llevar un historial de todos los cambios que hagamos.

bash
# Crear una carpeta para el proyecto
mkdir pasteles-app
cd pasteles-app

# Inicializar repositorio Git
git init

# Crear archivo .gitignore para ignorar archivos innecesarios
echo "/vendor/
/node_modules/
.env
.DS_Store
/storage/*.key
/public/storage
/storage/*.log
.idea/
.vscode/
Homestead.json
Homestead.yaml
*.sqlite
*.sqlite-journal
" > .gitignore

1. Crear proyecto Laravel

bash
composer create-project laravel/laravel .

# O si prefieres crear el proyecto en una carpeta nueva:
composer create-project laravel/laravel pasteles-app
cd pasteles-app

📌 Guardar primer commit — Proyecto iniciado

bash
git add .
git commit -m "feat: iniciar proyecto Laravel con estructura base"

Configurar .env:

text
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=pasteles_db
DB_USERNAME=root
DB_PASSWORD=

Crear la base de datos:

sql
CREATE DATABASE pasteles_db;

2. Crear la migración

bash
php artisan make:migration create_pasteles_table

La estructura de datos será:

text
pasteles
-------------------------
id
nombre
sabor
precio
disponible
descripcion
created_at
updated_at
deleted_at

Migración mínima:

php
Schema::create('pasteles', function (Blueprint $table) {
    $table->id();
    $table->string('nombre', 100);
    $table->string('sabor', 50);
    $table->decimal('precio', 8, 2);
    $table->boolean('disponible')->default(true);
    $table->text('descripcion')->nullable();
    $table->timestamps();
    $table->softDeletes();
});

Ejecutar:

bash
php artisan migrate

📌 Guardar commit — Migración creada

bash
git add database/migrations/*.php
git commit -m "feat: crear migración de tabla pasteles"

3. Verificar la estructura

En MySQL:

sql
USE pasteles_db;

DESCRIBE pasteles;

También:

sql
SHOW TABLES;

Y:

sql
SELECT * FROM pasteles;

Aquí todavía no necesitamos Laravel.

Primero comprobamos:

text
MySQL
   ↓
¿Existe la tabla?
   ↓
¿Tiene los campos correctos?

4. Crear el modelo

bash
php artisan make:model Pastel

app/Models/Pastel.php

php
class Pastel extends Model
{
    use HasFactory, SoftDeletes;

    protected $fillable = [
        'nombre',
        'sabor',
        'precio',
        'disponible',
        'descripcion'
    ];
}

Ahora:

text
MySQL
   ↑
   │
 Pastel
   │
 Modelo Eloquent

📌 Guardar commit — Modelo creado

bash
git add app/Models/Pastel.php
git commit -m "feat: crear modelo Pastel con SoftDeletes y fillable"

5. Crear datos de prueba

Para esta primera prueba puedes introducir datos directamente en MySQL:

sql
INSERT INTO pasteles
(nombre, sabor, precio, disponible, descripcion)
VALUES
('Pastel de Chocolate', 'Chocolate', 350.00, 1, 'Pastel tradicional'),
('Pastel Tres Leches', 'Vainilla', 400.00, 1, 'Pastel con tres leches'),
('Cheesecake de Fresa', 'Fresa', 450.00, 1, 'Cheesecake con fresa');

Comprobar:

sql
SELECT * FROM pasteles;

6. Crear el controlador

bash
php artisan make:controller PastelController

app/Http/Controllers/PastelController.php

Primero solamente:

php
namespace App\Http\Controllers;

use App\Models\Pastel;

class PastelController extends Controller
{
    public function index()
    {
        $pasteles = Pastel::all();

        return view('pasteles.index', compact('pasteles'));
    }
}

Aquí está la parte importante del ejercicio:

text
Pastel::all()
     ↓
   $pasteles
     ↓
view()

El controlador recibe los datos del modelo y los manda a la vista.

📌 Guardar commit — Controlador creado

bash
git add app/Http/Controllers/PastelController.php
git commit -m "feat: crear PastelController con método index"

7. Crear las rutas

routes/web.php

php
use App\Http\Controllers\PastelController;

// Ruta para listar todos los pasteles (READ - Index)
Route::get('/pasteles', [PastelController::class, 'index'])->name('pasteles.index');

// Ruta para mostrar el formulario de creación (CREATE - Create)
Route::get('/pasteles/create', [PastelController::class, 'create'])->name('pasteles.create');

// Ruta para almacenar un nuevo pastel (CREATE - Store)
Route::post('/pasteles', [PastelController::class, 'store'])->name('pasteles.store');

// Ruta para mostrar los detalles de un pastel (READ - Show)
Route::get('/pasteles/{pastel}', [PastelController::class, 'show'])->name('pasteles.show');

// Ruta para mostrar el formulario de edición (UPDATE - Edit)
Route::get('/pasteles/{pastel}/edit', [PastelController::class, 'edit'])->name('pasteles.edit');

// Ruta para actualizar un pastel (UPDATE - Update)
Route::put('/pasteles/{pastel}', [PastelController::class, 'update'])->name('pasteles.update');

// Ruta para eliminar un pastel (DELETE - Destroy)
Route::delete('/pasteles/{pastel}', [PastelController::class, 'destroy'])->name('pasteles.destroy');

// Ruta para restaurar un pastel eliminado (Restaurar)
Route::patch('/pasteles/{pastel}/restore', [PastelController::class, 'restore'])->name('pasteles.restore');

📌 Guardar commit — Rutas creadas

bash
git add routes/web.php
git commit -m "feat: agregar rutas CRUD para pasteles"

8. Crear la vista mínima

Crear:

resources/views/pasteles/index.blade.php

Sin HTML elaborado:

blade
@foreach($pasteles as $pastel)

    {{ $pastel->id }}
    {{ $pastel->nombre }}
    {{ $pastel->sabor }}
    {{ $pastel->precio }}
    {{ $pastel->disponible }}
    {{ $pastel->descripcion }}

    <hr>

@endforeach

📌 Guardar commit — Vista creada

bash
git add resources/views/pasteles/
git commit -m "feat: crear vista index para listar pasteles"

Y listo.

Abrir:

text
http://localhost:8000/pasteles

Ejecutando antes:

bash
php artisan serve

Deberías obtener algo parecido a:

text
1
Pastel de Chocolate
Chocolate
350
1
Pastel tradicional

--------------------------------

2
Pastel Tres Leches
Vainilla
400
1
Pastel con tres leches

--------------------------------

3
Cheesecake de Fresa
Fresa
450
1
Cheesecake con fresa

🎯 ¿Qué acabamos de demostrar?

Este pequeño ejercicio demuestra todo el recorrido:

text
             MYSQL
               │
               │ SELECT
               ▼
        ┌──────────────┐
        │    MODELO    │
        │    Pastel    │
        └──────┬───────┘
               │
          Pastel::all()
               │
               ▼
        ┌──────────────┐
        │ CONTROLADOR  │
        │    index()   │
        └──────┬───────┘
               │
        $pasteles
               │
               ▼
        ┌──────────────┐
        │     BLADE    │
        │    index     │
        └──────────────┘
               │
               ▼
          DATOS EN PANTALLA

Todavía no existe CRUD. Y eso es intencional.

Primero:

text
✓ Base de datos
✓ Tabla
✓ Modelo
✓ Datos
✓ Controlador
✓ Ruta
✓ Vista
✓ Datos visibles

Después podemos agregar Create, luego Read, Update y finalmente Delete.

📌 Commit final del prototipo

bash
git add .
git commit -m "feat: completar prototipo funcional del flujo de datos"

📌 Ver historial de commits

bash
git log --oneline

Deberías ver algo como:

text
a1b2c3d feat: completar prototipo funcional del flujo de datos
e4f5g6h feat: crear vista index para listar pasteles
i7j8k9l feat: agregar rutas CRUD para pasteles
m0n1o2p feat: crear PastelController con método index
q3r4s5t feat: crear modelo Pastel con SoftDeletes y fillable
u6v7w8x feat: crear migración de tabla pasteles
y9z0a1b feat: iniciar proyecto Laravel con estructura base

📚 Resumen de comandos Git usados

ComandoDescripción
git initInicializa un repositorio Git en el proyecto
git add .Agrega todos los archivos modificados al área de staging
git add <archivo>Agrega un archivo específico
git commit -m "mensaje"Guarda los cambios con un mensaje descriptivo
git log --onelineMuestra el historial de commits resumido
git statusMuestra el estado actual de los archivos
git diffMuestra las diferencias entre cambios

Fases completas del curso

text
FASE 0  → Análisis y diseño
FASE 1  → Modelo de datos
FASE 2  → BD + Migración
FASE 3  → Modelo Eloquent
FASE 4  → Modelo → Controlador
FASE 5  → Controlador → Vista
FASE 6  → CRUD
FASE 7  → Validaciones
FASE 8  → Interfaz
FASE 9  → Mejoras

📌 Crear rama para el prototipo (opcional)

Si quieres mantener el prototipo separado del desarrollo posterior:

bash
# Crear y cambiar a una rama para el PoC
git checkout -b feature/prototipo-flujo-datos

# Cuando el prototipo esté listo, fusionar con la rama principal
git checkout main
git merge feature/prototipo-flujo-datos

Eso te da una ruta de desarrollo mucho más profesional que comenzar directamente haciendo el HTML del CRUD, y además tienes un historial completo de todos los cambios que has ido realizando.

Comentarios

Publicar un comentario

Entradas más populares de este blog

Tutorial CRUD con Laravel 12-Pastel::factory(50)->create();

    <a href = "{{ route('pasteles.create') }}" class = "btn btn-primary" >         <i class = "fas fa-plus" ></i> Nuevo Pastel     </a>   Introducción Este tutorial está diseñado para enseñarte a crear un sistema CRUD (Create, Read, Update, Delete) completo en Laravel 12, utilizando las últimas características y mejores prácticas del framework. A diferencia del tutorial original (diseñado para Laravel 5), esta versión incorpora las novedades de Laravel 12 y un enfoque más moderno. Índice Propósito Comando 1-Configuración inicial composer create-project laravel/laravel nombre-proyecto 2-Creación de la migración php artisan make:migration create_pasteles_table 3-Creación del seeder php artisan make:seeder PastelSeeder 4-Creación del modelo php artisan make:model Pastel 5-Creación del controlador php artisan make:controller PastelController 6-Definición de rutas php artisan route:list 7-Creación de vistas (Crear manua...
Leer más

CRUD Completo con Laravel 12 - Guía Práctica Paso a Paso-productos

  Introducción En este tutorial, construiremos una aplicación CRUD (Create, Read, Update, Delete) completa desde cero utilizando Laravel 12. Desarrollaremos un sistema de gestión de productos que te permitirá realizar todas las operaciones básicas de base de datos. Este tutorial es ideal para consolidar todos los conocimientos adquiridos en los temas anteriores. Índice Configuración del Proyecto Creación de la Migración Creación del Seeder Creación del Modelo Configuración del Enrutador Creación del Controlador Creación de las Vistas Ejecución y Pruebas Mejoras y Optimizaciones Ejercicio de Consolidación 1. Configuración del Proyecto Crear nuevo proyecto Laravel bash # Crear el proyecto composer create-project laravel/laravel crud-productos # Navegar al directorio cd crud-productos # Configurar archivo .env # Editar el archivo .env con tus credenciales de base de datos Configuración de la base de datos env DB_CONNECTION=mysql DB_HOST=127.0.0.1 DB_PORT=3306 DB_DATABASE=crud_p...
Leer más

CRUD en Laravel 12 con Git - Guía para Principiantes

CRUD en Laravel 12 con Git - Guía para Principiantes Este tutorial está diseñado especialmente para principiantes que quieren aprender a crear un sistema CRUD completo en Laravel 12 mientras aprenden a usar Git correctamente. Cada paso incluye instrucciones claras de Git para que nunca te pierdas. 📋 Tabla de Contenidos Instalación y Git - Paso a Paso Crear la Migración - Primer Commit Crear Factory y Seeder Crear el Modelo Crear el Controlador y Form Requests Definir las Rutas Crear las Vistas Flujo de Trabajo Git para Principiantes 🚀 1. Instalación y Git - Paso a Paso Requisitos Previos bash # 1. VERIFICAR INSTALACIONES # Abre tu terminal y escribe: # Verificar PHP (debe ser 8.2 o superior) php -v # Verificar Composer composer -V # Verificar Git (si no está instalado, descárgalo de https://git-scm.com) git --version Crear el Proyecto Laravel bash # 2. CREAR EL PROYECTO # Esto crea una carpeta llamada "pasteles-app" con Laravel 12 composer create-project la...
Leer más