feat: refactor cart item handling to use mapped buyable types and improve method signatures

app/Domains/Bundle/Models/Bundle.php

@@ -0,0 +1,145 @@
+<?php
+
+namespace App\Domains\Bundle\Models;
+
+use App\Domains\Tenant\Models\Tenant;
+use Illuminate\Database\Eloquent\Attributes\Fillable;
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+use Illuminate\Database\Eloquent\Casts\Attribute;
+
+use App\Domains\Shared\Contracts\Buyable;
+
+#[Fillable([
+    'tenant_codigo',
+    'nombre',
+    'descripcion',
+    'precio',
+])]
+class Bundle extends Model implements Buyable
+{
+    use HasFactory;
+
+    protected $table = 'bundles';
+
+    protected $appends = ['stock_tecnico'];
+
+    protected function casts(): array
+    {
+        return [
+            'precio' => 'decimal:2',
+        ];
+    }
+
+    /**
+     * @return BelongsTo<Tenant, $this>
+     */
+    public function tenant(): BelongsTo
+    {
+        return $this->belongsTo(Tenant::class, 'tenant_codigo', 'codigo');
+    }
+
+    /**
+     * @return HasMany<BundleItem, $this>
+     */
+    public function items(): HasMany
+    {
+        return $this->hasMany(BundleItem::class, 'bundle_id');
+    }
+
+    public function getPrice(): float
+    {
+        return (float) $this->precio;
+    }
+
+    public function getName(): string
+    {
+        return $this->nombre ?? 'Bundle';
+    }
+
+    public function incrementRealStock(int $amount): void
+    {
+        if ($amount < 0) {
+            throw new \InvalidArgumentException('El monto a incrementar debe ser positivo.');
+        }
+
+        foreach ($this->items as $item) {
+            $item->variant->incrementRealStock($amount * $item->cantidad);
+        }
+    }
+
+    public function decrementRealStock(int $amount): void
+    {
+        if ($amount < 0) {
+            throw new \InvalidArgumentException('El monto a decrementar debe ser positivo.');
+        }
+
+        foreach ($this->items as $item) {
+            $item->variant->decrementRealStock($amount * $item->cantidad);
+        }
+    }
+
+    public function incrementReservedStock(int $amount): void
+    {
+        if ($amount < 0) {
+            throw new \InvalidArgumentException('El monto a incrementar debe ser positivo.');
+        }
+
+        foreach ($this->items as $item) {
+            $item->variant->incrementReservedStock($amount * $item->cantidad);
+        }
+    }
+
+    public function decrementReservedStock(int $amount): void
+    {
+        if ($amount < 0) {
+            throw new \InvalidArgumentException('El monto a decrementar debe ser positivo.');
+        }
+
+        foreach ($this->items as $item) {
+            $item->variant->decrementReservedStock($amount * $item->cantidad);
+        }
+    }
+
+    public function confirmReservedStock(int $amount): void
+    {
+        if ($amount < 0) {
+            throw new \InvalidArgumentException('El monto a confirmar debe ser positivo.');
+        }
+
+        foreach ($this->items as $item) {
+            $item->variant->confirmReservedStock($amount * $item->cantidad);
+        }
+    }
+
+    public function validateStock(): void
+    {
+        if ($this->stock_tecnico <= 0) {
+            throw new \InvalidArgumentException('El bundle no tiene stock técnico disponible.');
+        }
+    }
+
+    protected function stockTecnico(): Attribute
+    {
+        return Attribute::get(function () {
+            if ($this->items->isEmpty()) {
+                return 0;
+            }
+            
+            $minStock = PHP_INT_MAX;
+            foreach ($this->items as $item) {
+                // Ensure variant is loaded
+                if ($item->variant) {
+                    $itemStock = floor($item->variant->stock_tecnico / $item->cantidad);
+                    if ($itemStock < $minStock) {
+                        $minStock = $itemStock;
+                    }
+                }
+            }
+            
+            return $minStock === PHP_INT_MAX ? 0 : (int) $minStock;
+        });
+    }
+}

app/Domains/Bundle/Models/BundleItem.php

@@ -0,0 +1,46 @@
+<?php
+
+namespace App\Domains\Bundle\Models;
+
+use App\Domains\Catalog\Models\ProductVariant;
+use Illuminate\Database\Eloquent\Attributes\Fillable;
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+
+#[Fillable([
+    'bundle_id',
+    'producto_variante_id',
+    'cantidad',
+])]
+class BundleItem extends Model
+{
+    use HasFactory;
+
+    protected $table = 'bundle_items';
+
+    protected function casts(): array
+    {
+        return [
+            'bundle_id' => 'integer',
+            'producto_variante_id' => 'integer',
+            'cantidad' => 'integer',
+        ];
+    }
+
+    /**
+     * @return BelongsTo<Bundle, $this>
+     */
+    public function bundle(): BelongsTo
+    {
+        return $this->belongsTo(Bundle::class, 'bundle_id');
+    }
+
+    /**
+     * @return BelongsTo<ProductVariant, $this>
+     */
+    public function variant(): BelongsTo
+    {
+        return $this->belongsTo(ProductVariant::class, 'producto_variante_id');
+    }
+}

app/Domains/Cart/Controllers/CartController.php

@@ -29,7 +29,8 @@ class CartController extends Controller
         $result = $this->cartService->addItem(
             $tenant,
             $request,
-            (int) $request->validated('product_variant_id'),
+            $request->mappedBuyableType(),
+            (int) $request->validated('buyable_id'),
             (int) $request->validated('cantidad'),
         );
 
@@ -47,22 +48,22 @@ class CartController extends Controller
     public function updateItemQuantity(
         UpdateCartItemQuantityRequest $request,
         Tenant $tenant,
-        ProductVariant $productVariant,
+        \App\Domains\Cart\Models\CartItem $cartItem,
     ): CartResource {
         return CartResource::make(
             $this->cartService->updateItemQuantity(
                 $tenant,
                 $request,
-                $productVariant->getKey(),
+                $cartItem->getKey(),
                 (int) $request->validated('cantidad'),
             )
         )->additional(['message' => 'Cantidad de producto actualizada.']);
     }
 
-    public function removeItem(Request $request, Tenant $tenant, ProductVariant $productVariant): CartResource
+    public function removeItem(Request $request, Tenant $tenant, \App\Domains\Cart\Models\CartItem $cartItem): CartResource
     {
         return CartResource::make(
-            $this->cartService->removeItem($tenant, $request, $productVariant->getKey())
+            $this->cartService->removeItem($tenant, $request, $cartItem->getKey())
         )->additional(['message' => 'Producto eliminado del carrito.']);
     }
 }

app/Domains/Cart/Models/Cart.php

@@ -63,15 +63,15 @@ class Cart extends Model
     {
         $items = $this->relationLoaded('items')
             ? $this->getRelation('items')
-            : $this->items()->with('variant.product')->get();
+            : $this->items()->with('buyable')->get();
 
         return (float) $items->reduce(
-            fn (float $carry, $item): float => $carry + ((float) ($item->variant?->product?->precio ?? 0) * $item->cantidad),
+            fn (float $carry, $item): float => $carry + ($item->buyable?->getPrice() * $item->cantidad),
             0.0,
         );
     }
 
-    public function addItem(int $productVariantId, int $quantity): CartItem
+    public function addItem(string $buyableType, int $buyableId, int $quantity): CartItem
     {
         if ($quantity <= 0) {
             throw ValidationException::withMessages([
@@ -79,24 +79,26 @@ class Cart extends Model
             ]);
         }
 
-        return DB::transaction(function () use ($productVariantId, $quantity): CartItem {
-            $variant = $this->resolveScopedVariant($productVariantId, true);
+        return DB::transaction(function () use ($buyableType, $buyableId, $quantity): CartItem {
+            $buyable = $this->resolveScopedBuyable($buyableType, $buyableId, true);
 
-            if ($variant->stock_tecnico < $quantity) {
+            if ($buyable->stock_tecnico < $quantity) {
                 throw ValidationException::withMessages([
-                    'cantidad' => "Stock insuficiente para la variante solicitada. Maximo disponible: {$variant->stock_tecnico}.",
+                    'cantidad' => "Stock insuficiente para la variante/bundle solicitado. Maximo disponible: {$buyable->stock_tecnico}.",
                 ]);
             }
 
             /** @var CartItem|null $item */
             $item = $this->items()
-                ->where('producto_variante_id', $variant->getKey())
+                ->where('buyable_type', $buyableType)
+                ->where('buyable_id', $buyable->getKey())
                 ->lockForUpdate()
                 ->first();
 
             if ($item === null) {
                 $item = $this->items()->create([
-                    'producto_variante_id' => $variant->getKey(),
+                    'buyable_type' => $buyableType,
+                    'buyable_id' => $buyable->getKey(),
                     'cantidad' => $quantity,
                 ]);
             } else {
@@ -104,13 +106,13 @@ class Cart extends Model
                 $item->save();
             }
 
-            $variant->incrementReservedStock($quantity);
+            $buyable->incrementReservedStock($quantity);
 
             return $item->fresh();
         });
     }
 
-    public function updateItem(int $productVariantId, int $quantity): CartItem
+    public function updateItem(int $cartItemId, int $quantity): CartItem
     {
         if ($quantity <= 0) {
             throw ValidationException::withMessages([
@@ -118,18 +120,18 @@ class Cart extends Model
             ]);
         }
 
-        return DB::transaction(function () use ($productVariantId, $quantity): CartItem {
+        return DB::transaction(function () use ($cartItemId, $quantity): CartItem {
             /** @var CartItem $item */
             $item = $this->items()
-                ->where('producto_variante_id', $productVariantId)
+                ->where('id', $cartItemId)
                 ->lockForUpdate()
                 ->firstOrFail();
 
-            $variant = $this->resolveScopedVariant($productVariantId, true);
+            $buyable = $this->resolveScopedBuyable($item->buyable_type, $item->buyable_id, true);
             $delta = $quantity - $item->cantidad;
 
-            if ($delta > 0 && $variant->stock_tecnico < $delta) {
-                $maxAvailable = $variant->stock_tecnico + $item->cantidad;
+            if ($delta > 0 && $buyable->stock_tecnico < $delta) {
+                $maxAvailable = $buyable->stock_tecnico + $item->cantidad;
                 throw ValidationException::withMessages([
                     'cantidad' => "El máximo que se puede agregar es {$maxAvailable}.",
                 ]);
@@ -139,49 +141,56 @@ class Cart extends Model
             $item->save();
 
             if ($delta > 0) {
-                $variant->incrementReservedStock($delta);
+                $buyable->incrementReservedStock($delta);
             }
 
             if ($delta < 0) {
-                $variant->decrementReservedStock(abs($delta));
+                $buyable->decrementReservedStock(abs($delta));
             }
 
             return $item->fresh();
         });
     }
 
-    public function removeItem(int $productVariantId): void
+    public function removeItem(int $cartItemId): void
     {
-        DB::transaction(function () use ($productVariantId): void {
+        DB::transaction(function () use ($cartItemId): void {
             /** @var CartItem $item */
             $item = $this->items()
-                ->where('producto_variante_id', $productVariantId)
+                ->where('id', $cartItemId)
                 ->lockForUpdate()
                 ->firstOrFail();
 
-            $variant = $this->resolveScopedVariant($productVariantId, true);
-            $variant->decrementReservedStock($item->cantidad);
+            $buyable = $this->resolveScopedBuyable($item->buyable_type, $item->buyable_id, true);
+            $buyable->decrementReservedStock($item->cantidad);
             $item->delete();
         });
     }
 
-    protected function resolveScopedVariant(int $productVariantId, bool $lockForUpdate = false): ProductVariant
+    protected function resolveScopedBuyable(string $buyableType, int $buyableId, bool $lockForUpdate = false)
     {
-        $query = ProductVariant::query()
-            ->whereKey($productVariantId)
-            ->whereHas('product', fn ($query) => $query->where('tenant_codigo', $this->tenant_codigo));
+        if ($buyableType === \App\Domains\Catalog\Models\ProductVariant::class) {
+            $query = \App\Domains\Catalog\Models\ProductVariant::query()
+                ->whereKey($buyableId)
+                ->whereHas('product', fn ($query) => $query->where('tenant_codigo', $this->tenant_codigo));
+        } elseif ($buyableType === \App\Domains\Bundle\Models\Bundle::class) {
+            $query = \App\Domains\Bundle\Models\Bundle::query()
+                ->whereKey($buyableId)
+                ->where('tenant_codigo', $this->tenant_codigo);
+        } else {
+            throw new \InvalidArgumentException('Invalid buyable type');
+        }
 
         if ($lockForUpdate) {
             $query->lockForUpdate();
         }
 
-        /** @var ProductVariant|null $variant */
-        $variant = $query->first();
+        $buyable = $query->first();
 
-        if ($variant === null) {
-            throw new NotFoundHttpException('Product variant not found for tenant.');
+        if ($buyable === null) {
+            throw new NotFoundHttpException('Buyable not found for tenant.');
         }
 
-        return $variant;
+        return $buyable;
     }
 }

app/Domains/Cart/Models/CartItem.php

@@ -10,7 +10,8 @@ use Illuminate\Database\Eloquent\Relations\BelongsTo;
 
 #[Fillable([
     'cart_id',
-    'producto_variante_id',
+    'buyable_id',
+    'buyable_type',
     'cantidad',
 ])]
 class CartItem extends Model
@@ -23,7 +24,8 @@ class CartItem extends Model
     {
         return [
             'cart_id' => 'integer',
-            'producto_variante_id' => 'integer',
+            'buyable_id' => 'integer',
+            'buyable_type' => 'string',
             'cantidad' => 'integer',
         ];
     }
@@ -37,10 +39,10 @@ class CartItem extends Model
     }
 
     /**
-     * @return BelongsTo<ProductVariant, $this>
+     * @return \Illuminate\Database\Eloquent\Relations\MorphTo
      */
-    public function variant(): BelongsTo
+    public function buyable()
     {
-        return $this->belongsTo(ProductVariant::class, 'producto_variante_id');
+        return $this->morphTo();
     }
 }

app/Domains/Cart/Requests/AddCartItemRequest.php

@@ -17,8 +17,18 @@ class AddCartItemRequest extends FormRequest
     public function rules(): array
     {
         return [
-            'product_variant_id' => ['required', 'integer'],
+            'buyable_type' => ['required', 'string', \Illuminate\Validation\Rule::in(['variant', 'bundle'])],
+            'buyable_id' => ['required', 'integer'],
             'cantidad' => ['required', 'integer', 'min:1'],
         ];
     }
+
+    public function mappedBuyableType(): string
+    {
+        return match ($this->input('buyable_type')) {
+            'variant' => \App\Domains\Catalog\Models\ProductVariant::class,
+            'bundle' => \App\Domains\Bundle\Models\Bundle::class,
+            default => throw new \InvalidArgumentException('Invalid buyable type'),
+        };
+    }
 }

app/Domains/Cart/Resources/CartItemResource.php

@@ -15,29 +15,15 @@ class CartItemResource extends JsonResource
      */
     public function toArray(Request $request): array
     {
-        $variant = $this->variant;
-        $product = $variant?->product;
-
-        $attributesText = '';
-        if ($variant && $variant->relationLoaded('definitions')) {
-            $attributesText = $variant->definitions
-                ->map(function ($definition) {
-                    $attrName = $definition->productAttribute?->attribute?->nombre;
-                    $value = $definition->value;
-                    return $attrName ? "{$attrName}: {$value}" : $value;
-                })
-                ->filter()
-                ->implode(', ');
-        }
-
-        $productName = $product?->nombre;
-        if ($productName && $attributesText !== '') {
-            $productName .= " ({$attributesText})";
-        }
-
+        /** @var \App\Domains\Shared\Contracts\Buyable|null $buyable */
+        $buyable = $this->buyable;
+        
+        $productName = $buyable?->getName();
+        $precio = $buyable?->getPrice();
+        
         $imageUrl = null;
-        if ($variant && $variant->relationLoaded('attachments')) {
-            $firstAttachment = $variant->attachments->first();
+        if ($this->buyable_type === \App\Domains\Catalog\Models\ProductVariant::class && $buyable && $buyable->relationLoaded('attachments')) {
+            $firstAttachment = $buyable->attachments->first();
             if ($firstAttachment) {
                 $imageUrl = $firstAttachment->getTemporaryUrl(1440);
             }
@@ -46,16 +32,25 @@ class CartItemResource extends JsonResource
         return [
             'id' => $this->id,
             'cantidad' => $this->cantidad,
-            'precio_unitario' => $this->formatMoney($product?->precio),
-            'product_id' => $product?->id,
-            'product_variant_id' => $this->producto_variante_id,
-            'product' => $product === null ? null : [
+            'precio_unitario' => $this->formatMoney($precio),
+            'buyable_type' => $this->mapBuyableTypeToAlias($this->buyable_type),
+            'buyable_id' => $this->buyable_id,
+            'product' => $buyable === null ? null : [
                 'nombre' => $productName,
                 'imagen' => $imageUrl,
             ],
         ];
     }
 
+    protected function mapBuyableTypeToAlias(?string $type): string
+    {
+        return match ($type) {
+            \App\Domains\Catalog\Models\ProductVariant::class => 'variant',
+            \App\Domains\Bundle\Models\Bundle::class => 'bundle',
+            default => 'unknown',
+        };
+    }
+
     protected function formatMoney(float|int|string|null $amount): string
     {
         return number_format((float) ($amount ?? 0), 2, '.', '');

app/Domains/Cart/Services/CartService.php

@@ -32,12 +32,12 @@ class CartService
     /**
      * @return array{cart: Cart, guest_token: ?string}
      */
-    public function addItem(Tenant $tenant, Request $request, int $productVariantId, int $quantity): array
+    public function addItem(Tenant $tenant, Request $request, string $buyableType, int $buyableId, int $quantity): array
     {
         $resolvedIdentity = $this->resolveIdentity($request, true);
         $identity = $resolvedIdentity['identity'];
         $cart = $this->findOrCreateCart($tenant, $identity);
-        $cart->addItem($productVariantId, $quantity);
+        $cart->addItem($buyableType, $buyableId, $quantity);
 
         return [
             'cart' => $this->loadCart($cart),
@@ -45,20 +45,20 @@ class CartService
         ];
     }
 
-    public function updateItemQuantity(Tenant $tenant, Request $request, int $productVariantId, int $quantity): Cart
+    public function updateItemQuantity(Tenant $tenant, Request $request, int $cartItemId, int $quantity): Cart
     {
         $identity = $this->requireIdentity($request);
         $cart = $this->findCartOrFail($tenant, $identity);
-        $cart->updateItem($productVariantId, $quantity);
+        $cart->updateItem($cartItemId, $quantity);
 
         return $this->loadCart($cart);
     }
 
-    public function removeItem(Tenant $tenant, Request $request, int $productVariantId): Cart
+    public function removeItem(Tenant $tenant, Request $request, int $cartItemId): Cart
     {
         $identity = $this->requireIdentity($request);
         $cart = $this->findCartOrFail($tenant, $identity);
-        $cart->removeItem($productVariantId);
+        $cart->removeItem($cartItemId);
 
         return $this->loadCart($cart);
     }

app/Domains/Cart/routes/api.php

@@ -8,6 +8,6 @@ Route::prefix('tenants/{tenant:codigo}')
     ->group(function (): void {
         Route::get('cart', [CartController::class, 'show']);
         Route::post('cart/items', [CartController::class, 'addItem']);
-        Route::patch('cart/items/{productVariant}', [CartController::class, 'updateItemQuantity']);
-        Route::delete('cart/items/{productVariant}', [CartController::class, 'removeItem']);
+        Route::patch('cart/items/{cartItem}', [CartController::class, 'updateItemQuantity']);
+        Route::delete('cart/items/{cartItem}', [CartController::class, 'removeItem']);
     });

app/Domains/Catalog/Controllers/CatalogController.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Domains\Catalog\Controllers;
+
+use App\Domains\Catalog\Resources\CatalogFeaturedGroupResource;
+use App\Domains\Catalog\Models\FeaturedGroup;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Routing\Controller;
+
+class CatalogController extends Controller
+{
+    public function index(string $tenant): JsonResponse
+    {
+        $featuredGroups = FeaturedGroup::where('tenant_codigo', $tenant)
+            ->with(['featuredVariants' => function ($query) {
+                $query->orderBy('order');
+            }, 'featuredVariants.variant.product', 'featuredVariants.variant.attachments', 'featuredVariants.variant.product.attachments'])
+            ->orderBy('group_order')
+            ->get();
+
+        return response()->json(CatalogFeaturedGroupResource::collection($featuredGroups)->resolve());
+    }
+}

app/Domains/Catalog/Controllers/FeaturedGroupController.php

@@ -0,0 +1,51 @@
+<?php
+
+namespace App\Domains\Catalog\Controllers;
+
+use App\Domains\Catalog\Models\FeaturedGroup;
+use App\Domains\Catalog\Requests\StoreFeaturedGroupRequest;
+use App\Domains\Catalog\Requests\UpdateFeaturedGroupRequest;
+use App\Domains\Catalog\Resources\FeaturedGroupResource;
+use App\Domains\Catalog\Services\FeaturedGroupService;
+use Illuminate\Http\Resources\Json\AnonymousResourceCollection;
+use Illuminate\Routing\Controller;
+use Illuminate\Http\JsonResponse;
+
+class FeaturedGroupController extends Controller
+{
+    public function __construct(
+        private readonly FeaturedGroupService $featuredGroupService
+    ) {}
+
+    public function index(string $tenant): AnonymousResourceCollection
+    {
+        $groups = FeaturedGroup::where('tenant_codigo', $tenant)->get();
+        return FeaturedGroupResource::collection($groups);
+    }
+
+    public function store(StoreFeaturedGroupRequest $request, string $tenant): FeaturedGroupResource
+    {
+        $group = $this->featuredGroupService->createGroup($tenant, $request->validated());
+        return new FeaturedGroupResource($group);
+    }
+
+    public function show(string $tenant, FeaturedGroup $featuredGroup): FeaturedGroupResource
+    {
+        abort_if($featuredGroup->tenant_codigo !== $tenant, 404);
+        return new FeaturedGroupResource($featuredGroup->load('featuredVariants'));
+    }
+
+    public function update(UpdateFeaturedGroupRequest $request, string $tenant, FeaturedGroup $featuredGroup): FeaturedGroupResource
+    {
+        abort_if($featuredGroup->tenant_codigo !== $tenant, 404);
+        $group = $this->featuredGroupService->updateGroup($featuredGroup, $request->validated());
+        return new FeaturedGroupResource($group);
+    }
+
+    public function destroy(string $tenant, FeaturedGroup $featuredGroup): JsonResponse
+    {
+        abort_if($featuredGroup->tenant_codigo !== $tenant, 404);
+        $this->featuredGroupService->deleteGroup($featuredGroup);
+        return response()->json(null, 204);
+    }
+}

app/Domains/Catalog/Controllers/FeaturedVariantController.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace App\Domains\Catalog\Controllers;
+
+use App\Domains\Catalog\Models\FeaturedGroup;
+use App\Domains\Catalog\Models\FeaturedVariant;
+use App\Domains\Catalog\Requests\StoreFeaturedVariantRequest;
+use App\Domains\Catalog\Requests\UpdateFeaturedVariantRequest;
+use App\Domains\Catalog\Resources\FeaturedVariantResource;
+use Illuminate\Http\Resources\Json\AnonymousResourceCollection;
+use Illuminate\Routing\Controller;
+use Illuminate\Http\JsonResponse;
+
+class FeaturedVariantController extends Controller
+{
+    public function index(string $tenant, FeaturedGroup $featuredGroup): AnonymousResourceCollection
+    {
+        abort_if($featuredGroup->tenant_codigo !== $tenant, 404);
+        return FeaturedVariantResource::collection($featuredGroup->featuredVariants);
+    }
+
+    public function store(StoreFeaturedVariantRequest $request, string $tenant, FeaturedGroup $featuredGroup): FeaturedVariantResource
+    {
+        abort_if($featuredGroup->tenant_codigo !== $tenant, 404);
+        $variant = $featuredGroup->featuredVariants()->create($request->validated());
+        return new FeaturedVariantResource($variant);
+    }
+
+    public function update(UpdateFeaturedVariantRequest $request, string $tenant, FeaturedGroup $featuredGroup, FeaturedVariant $featuredVariant): FeaturedVariantResource
+    {
+        abort_if($featuredGroup->tenant_codigo !== $tenant || $featuredVariant->featured_group_id !== $featuredGroup->id, 404);
+        $featuredVariant->update($request->validated());
+        return new FeaturedVariantResource($featuredVariant);
+    }
+
+    public function destroy(string $tenant, FeaturedGroup $featuredGroup, FeaturedVariant $featuredVariant): JsonResponse
+    {
+        abort_if($featuredGroup->tenant_codigo !== $tenant || $featuredVariant->featured_group_id !== $featuredGroup->id, 404);
+        $featuredVariant->delete();
+        return response()->json(null, 204);
+    }
+}

app/Domains/Catalog/Models/FeaturedGroup.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace App\Domains\Product\Models;
+namespace App\Domains\Catalog\Models;
 
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Relations\HasMany;
@@ -11,10 +11,11 @@ class FeaturedGroup extends Model
         'tenant_codigo',
         'group_name',
         'product_layout',
+        'group_order',
     ];
 
-    public function featuredProducts(): HasMany
+    public function featuredVariants(): HasMany
     {
-        return $this->hasMany(FeaturedProduct::class);
+        return $this->hasMany(FeaturedVariant::class);
     }
 }

app/Domains/Catalog/Models/FeaturedVariant.php

@@ -1,15 +1,18 @@
 <?php
 
-namespace App\Domains\Product\Models;
+namespace App\Domains\Catalog\Models;
 
+use App\Domains\Catalog\Models\ProductVariant;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;
 
-class FeaturedProduct extends Model
+class FeaturedVariant extends Model
 {
+    protected $table = 'featured_variants';
+
     protected $fillable = [
         'featured_group_id',
-        'product_id',
+        'product_variant_id',
         'order',
     ];
 
@@ -18,8 +21,8 @@ class FeaturedProduct extends Model
         return $this->belongsTo(FeaturedGroup::class);
     }
 
-    public function product(): BelongsTo
+    public function variant(): BelongsTo
     {
-        return $this->belongsTo(Product::class);
+        return $this->belongsTo(ProductVariant::class, 'product_variant_id');
     }
 }

app/Domains/Catalog/Models/ProductVariant.php

@@ -12,14 +12,19 @@ use Illuminate\Database\Eloquent\Relations\HasMany;
 
 use Illuminate\Database\Eloquent\Casts\Attribute;
 
+use App\Domains\Shared\Contracts\Buyable;
+
 #[Fillable([
     'producto_id',
     'stock_real',
     'stock_reservado',
     'stock',
     'is_placeholder',
+    'has_tickets',
+    'minimum_use_date',
+    'maximum_use_date',
 ])]
-class ProductVariant extends Model
+class ProductVariant extends Model implements Buyable
 {
     use HasFactory;
 
@@ -49,6 +54,28 @@ class ProductVariant extends Model
         }
     }
 
+    public function getPrice(): float
+    {
+        return (float) ($this->product->precio ?? 0.0);
+    }
+
+    public function getName(): string
+    {
+        $name = $this->product->nombre ?? 'Producto';
+        
+        if ($this->relationLoaded('definitions') && $this->definitions->isNotEmpty()) {
+            $definitions = $this->definitions->map(function ($def) {
+                return $def->value ?? $def->productAttribute?->attribute?->nombre;
+            })->filter()->implode(', ');
+            
+            if ($definitions !== '') {
+                $name .= " ({$definitions})";
+            }
+        }
+        
+        return $name;
+    }
+
     public function incrementRealStock(int $amount): void
     {
         if ($amount < 0) {
@@ -126,6 +153,9 @@ class ProductVariant extends Model
             'stock_real' => 'integer',
             'stock_reservado' => 'integer',
             'is_placeholder' => 'boolean',
+            'has_tickets' => 'boolean',
+            'minimum_use_date' => 'datetime',
+            'maximum_use_date' => 'datetime',
         ];
     }
 

app/Domains/Catalog/Requests/StoreFeaturedGroupRequest.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Domains\Catalog\Requests;
+
+use Illuminate\Foundation\Http\FormRequest;
+
+class StoreFeaturedGroupRequest extends FormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'group_name' => ['required', 'string', 'max:255'],
+            'product_layout' => ['required', 'string', 'in:row,column_with_image,column_with_cart,vertical_with_image,vertical_with_cart'],
+            'group_order' => ['nullable', 'integer'],
+        ];
+    }
+}

app/Domains/Catalog/Requests/StoreFeaturedVariantRequest.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Domains\Catalog\Requests;
+
+use Illuminate\Foundation\Http\FormRequest;
+
+class StoreFeaturedVariantRequest extends FormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'product_variant_id' => ['required', 'integer'],
+            'order' => ['nullable', 'integer'],
+        ];
+    }
+}

app/Domains/Catalog/Requests/StoreProductVariantRequest.php

@@ -32,6 +32,9 @@ class StoreProductVariantRequest extends FormRequest
             'definitions.*.value' => ['nullable', 'string'],
             'images' => ['sometimes', 'nullable', 'array'],
             'images.*' => ['required', new ImageOrBase64Rule()],
+            'has_tickets' => ['boolean'],
+            'minimum_use_date' => ['nullable', 'date'],
+            'maximum_use_date' => ['nullable', 'date', 'after_or_equal:minimum_use_date'],
         ];
     }
 }

app/Domains/Catalog/Requests/UpdateFeaturedGroupRequest.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Domains\Catalog\Requests;
+
+use Illuminate\Foundation\Http\FormRequest;
+
+class UpdateFeaturedGroupRequest extends FormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'group_name' => ['sometimes', 'string', 'max:255'],
+            'product_layout' => ['sometimes', 'string', 'in:row,column_with_image,column_with_cart,vertical_with_image,vertical_with_cart'],
+            'group_order' => ['nullable', 'integer'],
+        ];
+    }
+}

app/Domains/Catalog/Requests/UpdateFeaturedVariantRequest.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace App\Domains\Catalog\Requests;
+
+use Illuminate\Foundation\Http\FormRequest;
+
+class UpdateFeaturedVariantRequest extends FormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'order' => ['sometimes', 'integer'],
+        ];
+    }
+}

app/Domains/Catalog/Requests/UpdateProductVariantRequest.php

@@ -32,6 +32,9 @@ class UpdateProductVariantRequest extends FormRequest
             'definitions.*.value' => ['nullable', 'string'],
             'images' => ['sometimes', 'nullable', 'array'],
             'images.*' => ['required', new ImageOrBase64Rule()],
+            'has_tickets' => ['boolean'],
+            'minimum_use_date' => ['nullable', 'date'],
+            'maximum_use_date' => ['nullable', 'date', 'after_or_equal:minimum_use_date'],
         ];
     }
 }

app/Domains/Catalog/Resources/CatalogFeaturedGroupResource.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace App\Domains\Catalog\Resources;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+use App\Domains\Catalog\Models\FeaturedVariant;
+
+class CatalogFeaturedGroupResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'id' => $this->id,
+            'title' => $this->group_name,
+            'layout' => $this->product_layout,
+            'group_order' => $this->group_order,
+            'items' => $this->whenLoaded('featuredVariants', function () use ($request) {
+                return $this->featuredVariants->map(function (FeaturedVariant $featuredVariant) use ($request) {
+                    $variant = $featuredVariant->variant;
+                    $variantResource = (new ProductVariantResource($variant))->toArray($request);
+                    
+                    if ($this->product_layout === 'row' || $this->product_layout === 'column_with_cart' || $this->product_layout === 'vertical_with_cart') {
+                        // Devuelve el Product Variant Resource completo como pidio el usuario
+                        // "Que todo devuelva el product variant resource"
+                        return $variantResource;
+                    }
+                    
+                    // Para column_with_image o vertical_with_image
+                    if ($this->product_layout === 'column_with_image' || $this->product_layout === 'vertical_with_image') {
+                        if (isset($variantResource['images']) && count($variantResource['images']) > 0) {
+                            $variantResource['images'] = [$variantResource['images'][0]];
+                        }
+                        return $variantResource;
+                    }
+                    
+                    return $variantResource;
+                });
+            }),
+        ];
+    }
+}

app/Domains/Catalog/Resources/FeaturedGroupResource.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Domains\Catalog\Resources;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class FeaturedGroupResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'id' => $this->id,
+            'tenant_codigo' => $this->tenant_codigo,
+            'group_name' => $this->group_name,
+            'product_layout' => $this->product_layout,
+            'group_order' => $this->group_order,
+            'featured_variants' => FeaturedVariantResource::collection($this->whenLoaded('featuredVariants')),
+        ];
+    }
+}

app/Domains/Catalog/Resources/FeaturedVariantResource.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace App\Domains\Catalog\Resources;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class FeaturedVariantResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'id' => $this->id,
+            'featured_group_id' => $this->featured_group_id,
+            'product_variant_id' => $this->product_variant_id,
+            'order' => $this->order,
+        ];
+    }
+}

app/Domains/Catalog/Resources/ProductResource.php

@@ -26,6 +26,7 @@ class ProductResource extends JsonResource
             'precio' => $this->precio,
             'category' => $this->whenLoaded('category', fn () => $this->category?->nombre),
             'brand' => $this->whenLoaded('brand', fn () => $this->brand?->nombre),
+
             'images' => $this->whenLoaded('attachments', fn () => $this->attachments
                 ->map(fn ($attachment) => $attachment->getTemporaryUrl(1440))
                 ->values()

app/Domains/Catalog/Resources/ProductVariantResource.php

@@ -19,6 +19,9 @@ class ProductVariantResource extends JsonResource
         return [
             'id' => $this->id,
             'cantidad_maxima' => $this->stock_tecnico,
+            'has_tickets' => $this->has_tickets,
+            'minimum_use_date' => $this->minimum_use_date,
+            'maximum_use_date' => $this->maximum_use_date,
             'product' => ProductResource::make($this->whenLoaded('product')),
             'definitions' => $this->whenLoaded(
                 'definitions',

app/Domains/Catalog/Services/FeaturedGroupService.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace App\Domains\Catalog\Services;
+
+use App\Domains\Catalog\Models\FeaturedGroup;
+
+class FeaturedGroupService
+{
+    public function createGroup(string $tenantCodigo, array $data): FeaturedGroup
+    {
+        $data['tenant_codigo'] = $tenantCodigo;
+        return FeaturedGroup::create($data);
+    }
+
+    public function updateGroup(FeaturedGroup $group, array $data): FeaturedGroup
+    {
+        $group->update($data);
+        return $group;
+    }
+
+    public function deleteGroup(FeaturedGroup $group): bool|null
+    {
+        return $group->delete();
+    }
+}

app/Domains/Catalog/routes/api.php

@@ -1,13 +1,17 @@
 <?php
 
 use App\Domains\Catalog\Controllers\BrandController;
+use App\Domains\Catalog\Controllers\CatalogController;
 use App\Domains\Catalog\Controllers\CategoryController;
 use App\Domains\Catalog\Controllers\ProductController;
 use App\Domains\Catalog\Controllers\AttributeController;
 use App\Domains\Catalog\Controllers\ProductVariantController;
+use App\Domains\Catalog\Controllers\FeaturedGroupController;
+use App\Domains\Catalog\Controllers\FeaturedVariantController;
 use Illuminate\Support\Facades\Route;
 
 Route::prefix('tenants/{tenant:codigo}')->group(function (): void {
+    Route::get('catalog', [CatalogController::class, 'index']);
     Route::apiResource('marcas', BrandController::class)->parameters(['marcas' => 'marca']);
     Route::apiResource('categorias', CategoryController::class)->parameters(['categorias' => 'categoria']);
     Route::apiResource('productos', ProductController::class);
@@ -17,4 +21,11 @@ Route::prefix('tenants/{tenant:codigo}')->group(function (): void {
             'productos' => 'producto',
             'variants' => 'productVariant',
         ]);
+    Route::apiResource('featured-groups', FeaturedGroupController::class);
+    Route::apiResource('featured-groups.variants', FeaturedVariantController::class)
+        ->only(['index', 'store', 'update', 'destroy'])
+        ->parameters([
+            'featured-groups' => 'featuredGroup',
+            'variants' => 'featuredVariant',
+        ]);
 });

app/Domains/Purchase/Models/PurchaseItem.php

@@ -10,7 +10,8 @@ use Illuminate\Database\Eloquent\Relations\BelongsTo;
 
 #[Fillable([
     'compra_id',
-    'producto_variante_id',
+    'buyable_id',
+    'buyable_type',
     'cantidad',
     'precio_unitario',
     'discount_total',
@@ -27,7 +28,8 @@ class PurchaseItem extends Model
     {
         return [
             'compra_id' => 'integer',
-            'producto_variante_id' => 'integer',
+            'buyable_id' => 'integer',
+            'buyable_type' => 'string',
             'cantidad' => 'integer',
             'precio_unitario' => 'decimal:2',
             'discount_total' => 'decimal:2',
@@ -45,10 +47,10 @@ class PurchaseItem extends Model
     }
 
     /**
-     * @return BelongsTo<ProductVariant, $this>
+     * @return \Illuminate\Database\Eloquent\Relations\MorphTo
      */
-    public function variant(): BelongsTo
+    public function buyable()
     {
-        return $this->belongsTo(ProductVariant::class, 'producto_variante_id');
+        return $this->morphTo();
     }
 }

app/Domains/Purchase/Resources/PurchaseItemResource.php

@@ -17,30 +17,43 @@ class PurchaseItemResource extends JsonResource
      */
     public function toArray(Request $request): array
     {
-        $variant = $this->variant;
-        $product = $variant?->product;
+        /** @var \App\Domains\Shared\Contracts\Buyable|null $buyable */
+        $buyable = $this->buyable;
         $quantity = (int) ($this->cantidad ?? 0);
         $unitPrice = $this->resolveUnitPrice();
         $lineTotal = $this->resolveLineTotal($unitPrice, $quantity);
 
+        $imageUrl = null;
+        $attributes = [];
+        if ($this->buyable_type === \App\Domains\Catalog\Models\ProductVariant::class && $buyable) {
+            $imageUrl = $this->resolveImageUrl($buyable);
+            $attributes = $this->resolveAttributes($buyable);
+        }
+
         return [
             'id' => $this->id,
             'quantity' => $quantity,
             'unit_price' => $this->formatMoney($unitPrice),
             'line_total' => $this->formatMoney($lineTotal),
-            'product' => $product === null ? null : [
-                'id' => $product->id,
-                'nombre' => $product->nombre,
-                'slug' => $product->slug,
-                'imagen' => $this->resolveImageUrl(),
-            ],
-            'variant' => $variant === null ? null : [
-                'id' => $variant->id,
-                'attributes' => $this->resolveAttributes(),
+            'buyable_type' => $this->mapBuyableTypeToAlias($this->buyable_type),
+            'buyable_id' => $this->buyable_id,
+            'item_details' => $buyable === null ? null : [
+                'nombre' => $buyable->getName(),
+                'imagen' => $imageUrl,
+                'attributes' => $attributes,
             ],
         ];
     }
 
+    protected function mapBuyableTypeToAlias(?string $type): string
+    {
+        return match ($type) {
+            \App\Domains\Catalog\Models\ProductVariant::class => 'variant',
+            \App\Domains\Bundle\Models\Bundle::class => 'bundle',
+            default => 'unknown',
+        };
+    }
+
     protected function resolveUnitPrice(): float
     {
         if ($this->resource instanceof PurchaseItem) {
@@ -48,7 +61,7 @@ class PurchaseItemResource extends JsonResource
         }
 
         if ($this->resource instanceof CartItem) {
-            return (float) ($this->variant?->product?->precio ?? 0);
+            return (float) ($this->buyable?->getPrice() ?? 0);
         }
 
         return 0.0;
@@ -63,15 +76,13 @@ class PurchaseItemResource extends JsonResource
         return $unitPrice * $quantity;
     }
 
-    protected function resolveImageUrl(): ?string
+    protected function resolveImageUrl($buyable): ?string
     {
-        $variant = $this->variant;
-
-        if ($variant === null || ! $variant->relationLoaded('attachments')) {
+        if (! $buyable->relationLoaded('attachments')) {
             return null;
         }
 
-        $attachment = $variant->attachments->first();
+        $attachment = $buyable->attachments->first();
 
         if ($attachment === null) {
             return null;
@@ -83,15 +94,13 @@ class PurchaseItemResource extends JsonResource
     /**
      * @return array<int, array{name: string, value: mixed}>
      */
-    protected function resolveAttributes(): array
+    protected function resolveAttributes($buyable): array
     {
-        $variant = $this->variant;
-
-        if ($variant === null || ! $variant->relationLoaded('definitions')) {
+        if (! $buyable->relationLoaded('definitions')) {
             return [];
         }
 
-        return $variant->definitions
+        return $buyable->definitions
             ->map(function ($definition): array {
                 return [
                     'name' => (string) ($definition->productAttribute?->attribute?->nombre ?? ''),

app/Domains/Purchase/Services/CheckoutService.php

@@ -29,7 +29,7 @@ class CheckoutService
                 ]);
             }
 
-            $cartItems->load('variant.product');
+            $cartItems->load('buyable');
             $cart->setRelation('items', $cartItems);
             $totalAmount = $cart->getTotalAmount();
 
@@ -63,7 +63,7 @@ class CheckoutService
                 $purchase->save();
             }
 
-            return $purchase->load(['items.variant.product', 'items.variant.definitions.productAttribute.attribute']);
+            return $purchase->load(['items.buyable']);
         });
     }
 
@@ -82,7 +82,7 @@ class CheckoutService
             }
 
             if (in_array($purchase->status, [Purchase::STATUS_PAID, Purchase::STATUS_CANCELLED, Purchase::STATUS_REJECTED], true)) {
-                return $purchase->load(['items.variant.product', 'items.variant.definitions.productAttribute.attribute']);
+                return $purchase->load(['items.buyable']);
             }
 
             $purchase->update([
@@ -90,7 +90,7 @@ class CheckoutService
                 'total' => $purchase->calculateCurrentTotalAmount(),
             ]);
 
-            return $purchase->load(['items.variant.product', 'items.variant.definitions.productAttribute.attribute']);
+            return $purchase->load(['items.buyable']);
         });
     }
 
@@ -118,42 +118,36 @@ class CheckoutService
                 return;
             }
 
-            $cartItems->load('variant.product');
-            $variants = $this->resolveTenantVariants($purchase->tenant, $cartItems);
-            $purchaseItemsPayload = $this->buildPurchaseItemsPayload($cartItems, $variants);
+            $cartItems->load('buyable');
+            $this->verifyTenantBuyables($purchase->tenant, $cartItems);
+            $purchaseItemsPayload = $this->buildPurchaseItemsPayload($cartItems);
 
             $purchase->items()->createMany($purchaseItemsPayload);
-            $this->completeCartConversion($cart, $cartItems, $variants);
+            $this->completeCartConversion($cart, $cartItems);
         });
     }
 
-    /**
-     * @return Collection<int, ProductVariant>
-     */
-    protected function resolveTenantVariants(Tenant $tenant, Collection $cartItems): Collection
+    protected function verifyTenantBuyables(Tenant $tenant, Collection $cartItems): void
     {
-        $variantIds = $cartItems
-            ->pluck('producto_variante_id')
-            ->map(static fn (mixed $id): int => (int) $id)
-            ->unique()
-            ->values();
-
-        /** @var Collection<int, ProductVariant> $variants */
-        $variants = ProductVariant::query()
-            ->with('product')
-            ->whereIn('id', $variantIds)
-            ->whereHas('product', fn ($query) => $query->where('tenant_codigo', $tenant->codigo))
-            ->lockForUpdate()
-            ->get()
-            ->keyBy('id');
-
-        if ($variants->count() !== $variantIds->count()) {
-            throw ValidationException::withMessages([
-                'cart_id' => 'One or more product variants do not belong to the tenant.',
-            ]);
+        foreach ($cartItems as $item) {
+            $buyable = $item->buyable;
+            if ($buyable === null) {
+                throw ValidationException::withMessages([
+                    'cart_id' => 'One or more buyables could not be loaded.',
+                ]);
+            }
+            
+            // Check tenant relation depending on type
+            if ($item->buyable_type === \App\Domains\Catalog\Models\ProductVariant::class && $buyable->product->tenant_codigo !== $tenant->codigo) {
+                throw ValidationException::withMessages([
+                    'cart_id' => 'One or more product variants do not belong to the tenant.',
+                ]);
+            } elseif ($item->buyable_type === \App\Domains\Bundle\Models\Bundle::class && $buyable->tenant_codigo !== $tenant->codigo) {
+                throw ValidationException::withMessages([
+                    'cart_id' => 'One or more bundles do not belong to the tenant.',
+                ]);
+            }
         }
-
-        return $variants;
     }
 
     /**
@@ -182,20 +176,19 @@ class CheckoutService
 
     /**
      * @param  Collection<int, CartItem>  $cartItems
-     * @param  Collection<int, ProductVariant>  $variants
      * @return array<int, array<string, mixed>>
      */
-    protected function buildPurchaseItemsPayload(Collection $cartItems, Collection $variants): array
+    protected function buildPurchaseItemsPayload(Collection $cartItems): array
     {
         return $cartItems
-            ->map(function (CartItem $item) use ($variants): array {
-                /** @var ProductVariant $variant */
-                $variant = $variants->get((int) $item['producto_variante_id']);
+            ->map(function (CartItem $item): array {
+                $buyable = $item->buyable;
                 $quantity = (int) $item['cantidad'];
-                $unitPrice = (float) ($variant->product?->precio ?? 0);
+                $unitPrice = $buyable?->getPrice() ?? 0;
 
                 return [
-                    'producto_variante_id' => $variant->getKey(),
+                    'buyable_type' => $item->buyable_type,
+                    'buyable_id' => $item->buyable_id,
                     'cantidad' => $quantity,
                     'precio_unitario' => $unitPrice,
                     'discount_total' => null,
@@ -208,17 +201,15 @@ class CheckoutService
 
     /**
      * @param  Collection<int, CartItem>  $cartItems
-     * @param  Collection<int, ProductVariant>  $variants
      */
-    protected function completeCartConversion(Cart $cart, Collection $cartItems, Collection $variants): void
+    protected function completeCartConversion(Cart $cart, Collection $cartItems): void
     {
         foreach ($cartItems as $item) {
-            /** @var ProductVariant $variant */
-            $variant = $variants->get((int) $item->producto_variante_id);
+            $buyable = $item->buyable;
             $quantity = (int) $item->cantidad;
 
             try {
-                $variant->confirmReservedStock($quantity);
+                $buyable->confirmReservedStock($quantity);
             } catch (\InvalidArgumentException $exception) {
                 throw ValidationException::withMessages([
                     'cart_id' => 'The selected cart has inconsistent stock state.',

app/Domains/Shared/Contracts/Buyable.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace App\Domains\Shared\Contracts;
+
+interface Buyable
+{
+    public function getPrice(): float;
+    public function getName(): string;
+
+    public function incrementRealStock(int $amount): void;
+    public function decrementRealStock(int $amount): void;
+    
+    public function incrementReservedStock(int $amount): void;
+    public function decrementReservedStock(int $amount): void;
+    public function confirmReservedStock(int $amount): void;
+    
+    public function validateStock(): void;
+}

app/Domains/Tenant/Models/Tenant.php

@@ -63,6 +63,14 @@ class Tenant extends Model
         return $this->belongsTo(Attachment::class, 'footer_logo_id');
     }
 
+    /**
+     * @return BelongsTo<Attachment, $this>
+     */
+    public function heroBgImage(): BelongsTo
+    {
+        return $this->belongsTo(Attachment::class, 'hero_bg_image_id');
+    }
+
     public function productos(): HasMany
     {
         return $this->hasMany(Product::class, 'tenant_codigo', 'codigo');

app/Domains/Tenant/Requests/StoreTenantRequest.php

@@ -61,8 +61,8 @@ class StoreTenantRequest extends FormRequest
             'footer_bg_color' => ['required', 'string', 'regex:/^#([a-fA-F0-9]{3,4}|[a-fA-F0-9]{6}|[a-fA-F0-9]{8})$/'],
             'header_logo' => $logoRule,
             'footer_logo' => $logoRule,
+            'hero_bg_image' => ['nullable', new ImageOrBase64Rule()],
             'hero_config' => ['nullable', 'array'],
-            'hero_config.background_image' => ['nullable', 'string'],
             'hero_config.title_html' => ['nullable', 'string'],
             'hero_config.description_html' => ['nullable', 'string'],
             'hero_config.button_text' => ['nullable', 'string'],

app/Domains/Tenant/Requests/UpdateTenantRequest.php

@@ -72,8 +72,8 @@ class UpdateTenantRequest extends FormRequest
             'footer_bg_color' => ['nullable', 'string', 'regex:/^#([a-fA-F0-9]{3,4}|[a-fA-F0-9]{6}|[a-fA-F0-9]{8})$/'],
             'header_logo' => $logoRule,
             'footer_logo' => $logoRule,
+            'hero_bg_image' => ['nullable', new ImageOrBase64Rule()],
             'hero_config' => ['nullable', 'array'],
-            'hero_config.background_image' => ['nullable', 'string'],
             'hero_config.title_html' => ['nullable', 'string'],
             'hero_config.description_html' => ['nullable', 'string'],
             'hero_config.button_text' => ['nullable', 'string'],

app/Domains/Tenant/Resources/TenantResource.php

@@ -15,6 +15,12 @@ class TenantResource extends JsonResource
      */
     public function toArray(Request $request): array
     {
+        $heroConfig = $this->hero_config;
+        if (is_array($heroConfig)) {
+            $heroConfig['background_image'] = $this->heroBgImage?->getTemporaryUrl(1440);
+            unset($heroConfig['background_image_id']);
+        }
+
         return [
             'id' => $this->id,
             'codigo' => $this->codigo,
@@ -29,7 +35,7 @@ class TenantResource extends JsonResource
             // 1 day
             'header_logo' => $this->headerLogo?->getTemporaryUrl(1440),
             'footer_logo' => $this->footerLogo?->getTemporaryUrl(1440 ),
-            'hero_config' => $this->hero_config,
+            'hero_config' => $heroConfig,
             'event_config' => $this->event_config,
             'menues' => $this->whenLoaded('menues'),
         ];

app/Domains/Tenant/Services/TenantService.php

@@ -24,8 +24,9 @@ class TenantService
         return DB::transaction(function () use ($data): Tenant {
             $headerLogo = $data['header_logo'] ?? null;
             $footerLogo = $data['footer_logo'] ?? null;
+            $heroBgImage = $data['hero_bg_image'] ?? null;
 
-            unset($data['header_logo'], $data['footer_logo']);
+            unset($data['header_logo'], $data['footer_logo'], $data['hero_bg_image']);
 
             $headerAttachmentId = null;
             if ($headerLogo) {
@@ -52,6 +53,18 @@ class TenantService
             $data['header_logo_id'] = $headerAttachmentId;
             $data['footer_logo_id'] = $footerAttachmentId;
 
+            if ($heroBgImage) {
+                $attachment = Str::isUuid($heroBgImage)
+                    ? \App\Domains\Attachable\Models\Attachment::query()->where('key', $heroBgImage)->first()
+                    : $this->attachmentService->store($heroBgImage, 'tenants');
+
+                if ($attachment) {
+                    $heroConfig = $data['hero_config'] ?? [];
+                    $heroConfig['background_image_id'] = $attachment->id;
+                    $data['hero_config'] = $heroConfig;
+                }
+            }
+
             /** @var Tenant $tenant */
             $tenant = Tenant::query()->create($data);
 
@@ -71,10 +84,14 @@ class TenantService
         return DB::transaction(function () use ($tenant, $data): Tenant {
             $hasHeaderLogoKey = array_key_exists('header_logo', $data);
             $hasFooterLogoKey = array_key_exists('footer_logo', $data);
+            $hasHeroBgImageKey = array_key_exists('hero_bg_image', $data);
             $headerLogo = $data['header_logo'] ?? null;
             $footerLogo = $data['footer_logo'] ?? null;
+            $heroBgImage = $data['hero_bg_image'] ?? null;
 
-            unset($data['header_logo'], $data['footer_logo']);
+            unset($data['header_logo'], $data['footer_logo'], $data['hero_bg_image']);
+
+            $oldHeroBgId = $tenant->hero_bg_image_id;
 
             $tenant->fill($data);
 
@@ -110,6 +127,28 @@ class TenantService
                 }
             }
 
+            $currentHeroConfig = $tenant->hero_config ?? [];
+            if ($hasHeroBgImageKey) {
+                if ($heroBgImage) {
+                    $attachment = Str::isUuid($heroBgImage)
+                        ? \App\Domains\Attachable\Models\Attachment::query()->where('key', $heroBgImage)->first()
+                        : $this->attachmentService->store($heroBgImage, 'tenants');
+
+                    if ($attachment) {
+                        $currentHeroConfig['background_image_id'] = $attachment->id;
+                    } else {
+                        unset($currentHeroConfig['background_image_id']);
+                    }
+                } else {
+                    unset($currentHeroConfig['background_image_id']);
+                }
+            } else {
+                if ($oldHeroBgId) {
+                    $currentHeroConfig['background_image_id'] = $oldHeroBgId;
+                }
+            }
+            $tenant->hero_config = empty($currentHeroConfig) ? null : $currentHeroConfig;
+
             $tenant->save();
 
             return $tenant;

database/migrations/2026_07_14_135000_add_hero_bg_image_id_virtual_column_to_tenants_table.php

@@ -0,0 +1,31 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::table('tenants', function (Blueprint $table) {
+            $table->unsignedBigInteger('hero_bg_image_id')
+                  ->virtualAs('hero_config->>"$.background_image_id"')
+                  ->nullable()
+                  ->after('footer_bg_color');
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::table('tenants', function (Blueprint $table) {
+            $table->dropColumn('hero_bg_image_id');
+        });
+    }
+};

database/migrations/2026_07_14_174706_add_group_order_to_featured_groups_table.php

@@ -0,0 +1,28 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::table('featured_groups', function (Blueprint $table) {
+            $table->integer('group_order')->default(0)->after('product_layout');
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::table('featured_groups', function (Blueprint $table) {
+            $table->dropColumn('group_order');
+        });
+    }
+};

database/migrations/2026_07_14_174819_rename_featured_products_to_featured_variants.php

@@ -0,0 +1,38 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        if (Schema::hasTable('featured_products')) {
+            Schema::rename('featured_products', 'featured_variants');
+        }
+
+        if (Schema::hasColumn('featured_variants', 'product_id')) {
+            Schema::table('featured_variants', function (Blueprint $table) {
+                $table->renameColumn('product_id', 'product_variant_id');
+            });
+        }
+
+        Schema::table('featured_variants', function (Blueprint $table) {
+            $table->foreign('product_variant_id')->references('id')->on('productos_variantes')->onDelete('cascade');
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::table('featured_variants', function (Blueprint $table) {
+            //
+        });
+    }
+};

database/migrations/2026_07_14_180621_add_ticket_fields_to_productos_table.php

@@ -0,0 +1,30 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::table('productos', function (Blueprint $table) {
+            $table->boolean('has_tickets')->default(false);
+            $table->dateTime('minimum_use_date')->nullable();
+            $table->dateTime('maximum_use_date')->nullable();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::table('productos', function (Blueprint $table) {
+            $table->dropColumn(['has_tickets', 'minimum_use_date', 'maximum_use_date']);
+        });
+    }
+};

database/migrations/2026_07_14_181346_move_ticket_fields_to_variantes_table.php

@@ -0,0 +1,40 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::table('productos', function (Blueprint $table) {
+            $table->dropColumn(['has_tickets', 'minimum_use_date', 'maximum_use_date']);
+        });
+        
+        Schema::table('productos_variantes', function (Blueprint $table) {
+            $table->boolean('has_tickets')->default(false);
+            $table->dateTime('minimum_use_date')->nullable();
+            $table->dateTime('maximum_use_date')->nullable();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::table('productos', function (Blueprint $table) {
+            $table->boolean('has_tickets')->default(false);
+            $table->dateTime('minimum_use_date')->nullable();
+            $table->dateTime('maximum_use_date')->nullable();
+        });
+
+        Schema::table('productos_variantes', function (Blueprint $table) {
+            $table->dropColumn(['has_tickets', 'minimum_use_date', 'maximum_use_date']);
+        });
+    }
+};

database/migrations/2026_07_14_184744_create_bundles_table.php

@@ -0,0 +1,33 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('bundles', function (Blueprint $table) {
+            $table->id();
+            $table->string('tenant_codigo', 10);
+            $table->string('nombre');
+            $table->text('descripcion')->nullable();
+            $table->decimal('precio', 10, 2);
+            $table->timestamps();
+
+            $table->foreign('tenant_codigo')->references('codigo')->on('tenants')->onDelete('cascade');
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('bundles');
+    }
+};

database/migrations/2026_07_14_184754_create_bundle_items_table.php

@@ -0,0 +1,30 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('bundle_items', function (Blueprint $table) {
+            $table->id();
+            $table->foreignId('bundle_id')->constrained('bundles')->onDelete('cascade');
+            $table->foreignId('producto_variante_id')->constrained('productos_variantes')->onDelete('cascade');
+            $table->integer('cantidad');
+            $table->timestamps();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('bundle_items');
+    }
+};

database/migrations/2026_07_14_184802_make_cart_items_polymorphic.php

@@ -0,0 +1,48 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::table('carrito_items', function (Blueprint $table) {
+            $table->string('buyable_type')->nullable();
+            $table->unsignedBigInteger('buyable_id')->nullable();
+        });
+
+        // Copy existing data
+        \Illuminate\Support\Facades\DB::table('carrito_items')->update([
+            'buyable_type' => 'App\Domains\Catalog\Models\ProductVariant',
+            'buyable_id' => \Illuminate\Support\Facades\DB::raw('producto_variante_id'),
+        ]);
+
+        Schema::table('carrito_items', function (Blueprint $table) {
+            $table->dropForeign(['producto_variante_id']);
+            $table->dropColumn('producto_variante_id');
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::table('carrito_items', function (Blueprint $table) {
+            $table->foreignId('producto_variante_id')->nullable()->constrained('productos_variantes')->onDelete('cascade');
+        });
+
+        \Illuminate\Support\Facades\DB::table('carrito_items')->update([
+            'producto_variante_id' => \Illuminate\Support\Facades\DB::raw('buyable_id'),
+        ]);
+
+        Schema::table('carrito_items', function (Blueprint $table) {
+            $table->dropColumn(['buyable_type', 'buyable_id']);
+        });
+    }
+};

database/migrations/2026_07_14_184812_make_purchase_items_polymorphic.php

@@ -0,0 +1,48 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::table('compra_items', function (Blueprint $table) {
+            $table->string('buyable_type')->nullable();
+            $table->unsignedBigInteger('buyable_id')->nullable();
+        });
+
+        // Copy existing data
+        \Illuminate\Support\Facades\DB::table('compra_items')->update([
+            'buyable_type' => 'App\Domains\Catalog\Models\ProductVariant',
+            'buyable_id' => \Illuminate\Support\Facades\DB::raw('producto_variante_id'),
+        ]);
+
+        Schema::table('compra_items', function (Blueprint $table) {
+            $table->dropForeign(['producto_variante_id']);
+            $table->dropColumn('producto_variante_id');
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::table('compra_items', function (Blueprint $table) {
+            $table->foreignId('producto_variante_id')->nullable()->constrained('productos_variantes')->onDelete('cascade');
+        });
+
+        \Illuminate\Support\Facades\DB::table('compra_items')->update([
+            'producto_variante_id' => \Illuminate\Support\Facades\DB::raw('buyable_id'),
+        ]);
+
+        Schema::table('compra_items', function (Blueprint $table) {
+            $table->dropColumn(['buyable_type', 'buyable_id']);
+        });
+    }
+};

database/seeders/TenantSeeder.php

@@ -100,6 +100,11 @@ class TenantSeeder extends Seeder
                     $attachmentService->delete($existingFiesta->footerLogo);
                 } catch (\Throwable $e) {}
             }
+            if ($existingFiesta->heroBgImage) {
+                try {
+                    $attachmentService->delete($existingFiesta->heroBgImage);
+                } catch (\Throwable $e) {}
+            }
             $existingFiesta->delete();
         }
 
@@ -111,6 +116,7 @@ class TenantSeeder extends Seeder
 
         $fiestaHeaderImagePath = public_path('images/futbol_infantil_header.png');
         $fiestaFooterImagePath = public_path('images/futbol_infantil_footer.png');
+        $fiestaHeroBgImagePath = public_path('images/futbol_infantil_hero.jpg');
 
         if (! file_exists($fiestaHeaderImagePath)) {
             throw new \RuntimeException("Image not found at path: {$fiestaHeaderImagePath}");
@@ -120,6 +126,10 @@ class TenantSeeder extends Seeder
             throw new \RuntimeException("Image not found at path: {$fiestaFooterImagePath}");
         }
 
+        if (! file_exists($fiestaHeroBgImagePath)) {
+            throw new \RuntimeException("Image not found at path: {$fiestaHeroBgImagePath}");
+        }
+
         $fiestaHeaderLogo = new UploadedFile(
             $fiestaHeaderImagePath,
             'futbol_infantil_header.png',
@@ -136,6 +146,14 @@ class TenantSeeder extends Seeder
             true
         );
 
+        $fiestaHeroBgImage = new UploadedFile(
+            $fiestaHeroBgImagePath,
+            'futbol_infantil_hero.jpg',
+            'image/jpeg',
+            null,
+            true
+        );
+
         $this->tenantService->create([
             'codigo' => 'fiesta_futbol_infantil',
             'nombre' => 'Fiesta Fútbol Infantil',
@@ -148,6 +166,7 @@ class TenantSeeder extends Seeder
             'footer_bg_color' => '#015327',
             'header_logo' => $fiestaHeaderLogo,
             'footer_logo' => $fiestaFooterLogo,
+            'hero_bg_image' => $fiestaHeroBgImage,
             'hero_config' => [
                 'title_html' => '<strong>ASEGURÁ TU LUGAR</strong>',
                 'description_html' => '<strong>Comprá tu entrada oficial en segundos</strong> de forma 100% segura. Preparate para vivir la experiencia completa.',

routes/api.php

@@ -11,3 +11,4 @@ require __DIR__.'/../app/Domains/Purchase/routes/api.php';
 require __DIR__.'/../app/Domains/Tenant/routes/api.php';
 require __DIR__.'/../app/Domains/Integration/routes/api.php';
 require __DIR__.'/../app/Domains/Menu/routes/api.php';
+