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

 Tu pregunta es clave: ¿cómo estructurar el pensamiento antes de teclear un solo comando? No se trata solo de memorizar php artisan make:..., sino de tener un flujo mental que te permita abordar cualquier proyecto (tienda, blog, inventario, etc.) con claridad.

Te voy a dar una guía paso a paso para que cada vez que tengas una nueva entidad (objeto) sepas exactamente qué hacer, en qué orden y por qué.

1. Fase de análisis: entender el objeto (antes del código)

Antes de abrir la terminal, respóndete estas preguntas:

  • ¿Cuál es la entidad principal?
    Ej: Pastel, Producto, Usuario, Pedido, Libro…

    • Nombre en singular (para modelo y controlador): Pastel

    • Nombre en plural (para tabla y ruta): pasteles (convención: tabla en plural y snake_case)

  • ¿Qué atributos tiene?
    Haz una lista con su tipo de dato (string, integer, decimal, boolean, text, date, etc.).
    Ej: nombre (string), precio (decimal), disponible (boolean), descripcion (text), sabor (enum).

  • ¿Qué validaciones necesitas?
    (requerido, único, formato, tamaño, etc.) – Esto te servirá para el FormRequest o la validación en el controlador.

  • ¿Tiene relaciones con otras tablas?
    (pertenece a, tiene muchos, etc.) – Esto define claves foráneas en la migración (foreignId, constrained).

  • ¿Qué operaciones CRUD necesitas?
    ¿Todo el CRUD (crear, leer, actualizar, eliminar) o solo algunas (ej: solo lectura para usuarios invitados)?

  • ¿Quién usará esto?
    (admin, cliente, invitado) – Define si necesitas autenticación, permisos, etc.

2. Flujo de creación (orden lógico de ejecución)

Una vez que tienes claras las respuestas, este es el orden recomendado:

Paso 1 – Crear la migración (la estructura de la tabla)

bash
php artisan make:migration create_pasteles_table

  • Define todas las columnas que identificaste en el análisis.

  • Usa tipos modernos: $table->id(), $table->softDeletes() si quieres borrado lógico, foreignId() para relaciones.

Paso 2 – Crear el modelo (la lógica de la entidad)

bash
php artisan make:model Pastel

(Si quieres ahorrar pasos, puedes hacer todo junto: php artisan make:model Pastel -m -c -r -f -s → crea migración, controlador resource, factory y seeder).

  • Define $fillable o $guarded (seguridad).

  • Agrega use SoftDeletes si lo usaste en la migración.

  • Define $casts para conversión de tipos.

  • Opcional: scopes, accesors, mutators.

Paso 3 – Crear el controlador (la lógica de negocio)

bash
php artisan make:controller PastelController --resource

  • Este comando crea los 7 métodos (index, create, store, show, edit, update, destroy).

  • Si usas API, usa --api (omite create y edit).

  • Dentro de cada método escribe la lógica:

    • index: obtener datos (con paginación, filtros, etc.) y retornar vista o JSON.

    • store/update: validar datos (puedes usar FormRequest) y guardar.

    • destroy: eliminar (físico o lógico).

Paso 4 – Definir las rutas (accesos públicos)

En routes/web.php:

php
use App\Http\Controllers\PastelController;

Route::resource('pasteles', PastelController::class);

Esa única línea genera todas las rutas CRUD con sus nombres (.index, .create, etc.).
Si necesitas rutas adicionales (como restore para soft delete), agrégalas aparte con un grupo.

Paso 5 – Crear las vistas (la interfaz de usuario)

  • Laravel no tiene un comando nativo para crear vistas blade.

  • Crea manualmente los archivos en resources/views/pasteles/:

    • index.blade.php (listado)

    • create.blade.php (formulario de creación)

    • edit.blade.php (formulario de edición)

    • show.blade.php (detalle)

  • Usa un layout común (layouts/app.blade.php) para no repetir HTML.

Paso 6 – Crear Factory y Seeder (datos de prueba)

bash
php artisan make:factory PastelFactory --model=Pastel
php artisan make:seeder PastelSeeder

  • En el factory, define cómo generar datos falsos con Faker.

  • En el seeder, usa Pastel::factory(50)->create().

  • Registra el seeder en DatabaseSeeder.php y luego ejecuta php artisan migrate --seed.

3. Plantilla mental (el "esqueleto" para cualquier objeto)

Cuando empieces un nuevo objeto, mentalmente repite esta secuencia:

  1. Objeto: Pastel (singular) → tabla pasteles (plural)

  2. Campos: nombre, sabor, precio, disponible, descripción

  3. Comando inicial: php artisan make:model Pastel -mcrf (modelo, migración, controlador resource y factory)

  4. Editar migración: agregar los campos con sus tipos

  5. Editar modelo: agregar $fillable y $casts

  6. Editar controlador: escribir validación y lógica (o usar FormRequest)

  7. Editar rutas: Route::resource('pasteles', PastelController::class)

  8. Crear vistas: archivos blade para index, create, edit, show

  9. Crear factory/seeder: para datos de prueba

  10. Ejecutar: php artisan migrate --seed y php artisan serve

4. Ejemplo concreto: si tuvieras que hacer un CRUD de "Libros"

  • Objeto: Libro (singular) → tabla libros

  • Campos: titulo, autor, isbn, precio, stock, publicado_en (date)

  • Comandos:

    bash
    php artisan make:model Libro -mcrf

  • Migración: agregar columnas

  • Modelo: $fillable = ['titulo','autor','isbn','precio','stock','publicado_en'];

  • Controlador: validar y guardar

  • Ruta: Route::resource('libros', LibroController::class);

  • Vistas: libros/index, libros/create, libros/edit, libros/show

  • Seeder: Libro::factory(30)->create()

5. Consejos para no perderte

  • Siempre piensa en singular/plural: modelo en singular, tabla en plural, ruta en plural.

  • Usa Route::resource para ahorrar código (genera las 7 rutas automáticamente).

  • Usa php artisan make:model -mcrf para crear todo de una vez (modelo, migración, controlador resource, factory). Luego solo editas los archivos generados.

  • No olvides los mensajes flash (with('success', '...')) para dar feedback al usuario.

  • Prueba siempre con php artisan route:list para verificar que tus rutas están bien.

Con esta estructura de pensamiento, cualquier proyecto nuevo lo encaras con la misma metodología: analizar → crear migración → modelo → controlador → rutas → vistas → datos de prueba.
El resto (relaciones, autenticación, permisos) se añade cuando lo necesites, pero el esqueleto base es siempre el mismo.

Regla General para Variables en PHP (dentro de Controladores y Vistas)

Todas las variables en PHP van en camelCase (primera letra minúscula, siguientes palabras con mayúscula).

  • ✅ Correcto: $pastelFavorito, $precioTotal, $nombreCompleto

  • ❌ Incorrecto: $pastel_favorito (eso es snake_case, se usa para columnas), $PastelFavorito (eso es PascalCase, se usa para clases).

Regla de Singular vs. Plural (La más importante en Laravel)

La decisión de usar singular o plural depende de cuántos elementos representa la variable:

Contexto¿Qué representa?ReglaEjemplo (Pastel)
Variable dentro del controladorUn solo registroSingular$pastel = Pastel::find(1);
Variable dentro del controladorUna lista de registrosPlural$pasteles = Pastel::all();
Parámetro en la ruta (URL)Un solo registro (inyección de modelo)SingularRoute::get('/pasteles/{pastel}', ...)
Variable enviada a la vistaLista de registrosPluralreturn view('index', compact('pasteles'));
Variable en la vista (foreach)Un elemento individual dentro del bucleSingular@foreach($pasteles as $pastel)

Tabla Comparativa por Capas (Tu "Guía Rápida")

Aquí tienes cómo debes nombrar todo según la capa de Laravel donde estés:

Capa / ElementoConvenciónEjemplo¿Por qué?
Clase del ModeloPascalCase (Singular)class PastelRepresenta una entidad única.
Tabla en BDsnake_case (Plural)pastelesLaravel asume plural para la tabla.
Columnas de la BDsnake_case (Singular)nombre, created_atEstándar SQL.
ControladorPascalCase (Singular) + ControllerPastelControllerNombrado por la entidad que gestiona.
Ruta (URI)snake_case o kebab-case (Plural)/pasteles o /lista-pastelesEs la URL pública, se usa plural.
Parámetro de Ruta (Model Binding)snake_case (Singular){pastel}Laravel lo usa para buscar UN modelo.
Nombre de la Ruta (name)snake_case con puntos (Singular/Plural según método)pasteles.index, pasteles.createConvención del framework.
Variable en Controller (1 item)camelCase (Singular)$pastelEs un objeto único.
Variable en Controller (varios)camelCase (Plural)$pastelesEs una colección de objetos.
Relación belongsTo / hasOnecamelCase (Singular)public function categoria()Devuelve UN modelo.
Relación hasMany / belongsToManycamelCase (Plural)public function ingredientes()Devuelve UNA colección.
FactoryPascalCase (Singular) + FactoryPastelFactoryFabrica instancias del modelo.
SeederPascalCase (Singular) + SeederPastelSeederSiembra datos de ese modelo.

Errores Comunes que debes evitar

  1. Poner la tabla en singular
    ❌ Schema::create('pastel', ...)
    ✅ Schema::create('pasteles', ...)
    Laravel infiere el nombre de la tabla a partir del modelo en plural. Si no lo haces, tendrás que usar protected $table = 'pastel'; en el modelo.

  2. Poner el parámetro de ruta en plural
    ❌ Route::get('/pasteles/{pasteles}', ...)
    ✅ Route::get('/pasteles/{pastel}', ...)
    Si pones {pasteles}, Laravel buscará una variable llamada así en el controlador, pero la inyección de modelos funciona con el nombre singular.

  3. Usar snake_case en variables PHP
    ❌ $pastel_favorito = ...
    ✅ $pastelFavorito = ...
    PHP usa snake_case para constantes y nombres de funciones internas, pero para variables propias se usa camelCase.

  4. Confundir el nombre del modelo con la tabla
    ❌ Modelo: Pasteles (plural)
    ✅ Modelo: Pastel (singular).
    El modelo siempre es singular porque representa una instancia (un pastel).

Resumen Ejecutivo (Para que lo imprimas y lo tengas a mano)

Variables PHP (dentro del código): camelCase
Si es UN objeto: singular ($pastel, $usuario, $producto)
Si es VARIOS objetos: plural ($pasteles, $usuarios, $productos)
Tablas y columnas: snake_case (tablas en plural, columnas en singular)
Clases y Controladores: PascalCase (singular)
Rutas URL: plural (/pasteles)
Parámetro de ruta: singular ({pastel})

Con esto, cuando empieces un nuevo proyecto, ya sabrás instintivamente:

  • El modelo se llama Producto.

  • La tabla se llama productos.

  • La variable para guardar uno es $producto.

  • La variable para el listado es $productos.

  • La ruta es /productos y el parámetro es {producto}.

¡Así de sencillo y sistemático! ¿Necesitas que profundice en cómo nombrar las relaciones (por ejemplo, pastelCategoria vs categoriaPastel)?


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