+
+ {attributeName.charAt(0).toUpperCase() + attributeName.slice(1)}
+
+
+ {variants!.map((variant) => (
+ handleVariantChange(variant.id)}
+ >
+ {variant.value}
+
+ ))}
+
+
Características
@@ -78,4 +174,4 @@ export default function Product({ loaderData }: Route.ComponentProps) {
);
-}
+}
\ No newline at end of file
diff --git a/src/routes/product/product.test.tsx b/src/routes/product/product.test.tsx
index f70059d..3c2c5c2 100644
--- a/src/routes/product/product.test.tsx
+++ b/src/routes/product/product.test.tsx
@@ -1,163 +1,123 @@
-import { render, screen } from "@testing-library/react";
-import { useNavigation } from "react-router";
+import { render, screen, fireEvent } from "@testing-library/react";
import { describe, expect, it, vi } from "vitest";
-import { createTestProduct } from "@/lib/utils.tests";
-import type { Product as ProductType } from "@/models/product.model";
+import { createTestProduct, createTestVariantAttributeValue } from "@/lib/utils.tests";
+import type { Product as ProductModel, VariantAttributeValueWithNumber } from "@/models/product.model";
import Product from ".";
import type { Route } from "./+types";
-// Helper function to create a test navigation object
-const createTestNavigation = (overrides = {}) => ({
- state: "idle" as const,
- location: undefined,
- formMethod: undefined,
- formAction: undefined,
- formEncType: undefined,
- formData: undefined,
- json: undefined,
- text: undefined,
- ...overrides,
-});
-
// Mock de react-router
-vi.mock("react-router", () => ({
- Form: vi.fn(({ children }) => ),
- useNavigation: vi.fn(() => createTestNavigation()),
- Link: vi.fn(({ children, ...props }) =>
{children} ),
-}));
+vi.mock("react-router", () => {
+ const actual = vi.importActual("react-router"); // mantener los demás exports reales
+ return {
+ ...actual,
+ Form: vi.fn(({ children }) =>
),
+ useNavigation: vi.fn(() => ({ state: "idle" } )),
+ useSearchParams: vi.fn(() => [new URLSearchParams(), vi.fn()]),
+ Link: vi.fn(({ children, ...props }) =>
{children} ),
+ };
+});
const createTestProps = (
- productData: Partial
= {}
+ productData: Partial = {}
): Route.ComponentProps => ({
loaderData: { product: createTestProduct(productData) },
params: { id: "123" },
- // Hack to satisfy type requirements
matches: [] as unknown as Route.ComponentProps["matches"],
});
describe("Product Component", () => {
describe("Rendering with valid product data", () => {
it("should render product title correctly", () => {
- // Step 1: Setup - Create test props
const props = createTestProps({ title: "Awesome Product" });
- // Step 2: Mock - Component mocks already set up above
- // Step 3: Call - Render component
render(Not Found Page
,
- // }));
- // Step 3: Call
- render( {
const cart = await getOrCreateCart(userId, sessionCartId);
- const existingItem = cart.items.find((item) => item.product.id === productId);
+ const existingItem = cart.items.find(
+ (item) => item.attributeValueId === attributeValueId
+ );
if (existingItem) {
const newQuantity = existingItem.quantity + quantity;
@@ -170,7 +180,7 @@ export async function alterQuantityCartItem(
await prisma.cartItem.create({
data: {
cartId: cart.id,
- productId,
+ attributeValueId: attributeValueId,
quantity,
},
});
@@ -236,14 +246,17 @@ export async function linkCartToUser(
include: {
items: {
include: {
- product: {
- select: {
- id: true,
- title: true,
- imgSrc: true,
- alt: true,
- price: true,
- isOnSale: true,
+ variantAttributeValue: {
+ include: {
+ product: {
+ select: {
+ id: true,
+ title: true,
+ imgSrc: true,
+ alt: true,
+ isOnSale: true,
+ },
+ },
},
},
},
@@ -258,9 +271,10 @@ export async function linkCartToUser(
items: updatedCart.items.map((item) => ({
...item,
product: {
- ...item.product,
- price: item.product.price.toNumber(),
+ ...item.variantAttributeValue.product,
+ price: item.variantAttributeValue.price.toNumber(),
},
+ variantAttributeValue: item.variantAttributeValue,
})),
};
}
@@ -285,41 +299,48 @@ export async function mergeGuestCartWithUserCart(
include: {
items: {
include: {
- product: {
- select: {
- id: true,
- title: true,
- imgSrc: true,
- alt: true,
- price: true,
- isOnSale: true,
+ variantAttributeValue: {
+ include: {
+ product: {
+ select: {
+ id: true,
+ title: true,
+ imgSrc: true,
+ alt: true,
+ isOnSale: true,
+ },
+ },
},
},
},
},
},
});
+
return {
...updatedCart,
items: updatedCart.items.map((item) => ({
...item,
product: {
- ...item.product,
- price: item.product.price.toNumber(),
+ ...item.variantAttributeValue.product,
+ price: item.variantAttributeValue.price.toNumber(),
},
+ variantAttributeValue: item.variantAttributeValue,
})),
};
}
// Obtener productos duplicados para eliminarlos del carrito del usuario
- const guestProductIds = guestCart.items.map((item) => item.productId);
+ const guestAttributeValueIds = guestCart.items.map(
+ (item) => item.attributeValueId
+ );
// Eliminar productos del carrito usuario que también existan en el carrito invitado
await prisma.cartItem.deleteMany({
where: {
cartId: userCart.id,
- productId: {
- in: guestProductIds,
+ attributeValueId: {
+ in: guestAttributeValueIds,
},
},
});
@@ -328,7 +349,7 @@ export async function mergeGuestCartWithUserCart(
await prisma.cartItem.createMany({
data: guestCart.items.map((item) => ({
cartId: userCart.id,
- productId: item.productId,
+ attributeValueId: item.attributeValueId,
quantity: item.quantity,
})),
});
@@ -341,3 +362,4 @@ export async function mergeGuestCartWithUserCart(
// Devolver el carrito actualizado del usuario
return await getCart(userId);
}
+
diff --git a/src/services/chat-system-prompt.ts b/src/services/chat-system-prompt.ts
index 30401b0..0313ad6 100644
--- a/src/services/chat-system-prompt.ts
+++ b/src/services/chat-system-prompt.ts
@@ -1,6 +1,6 @@
import type { CartWithItems } from "@/models/cart.model";
import type { Category } from "@/models/category.model";
-import type { Product } from "@/models/product.model";
+import type { Product, VariantAttributeValueWithNumber } from "@/models/product.model";
interface SystemPromptConfig {
categories: Category[];
@@ -13,32 +13,75 @@ export function generateSystemPrompt({
products,
userCart,
}: SystemPromptConfig): string {
- const onSaleProducts = products.filter((p) => p.isOnSale);
- const salesSection =
- onSaleProducts.length > 0
- ? `
+
+ // Procesar productos con información de variantes
+ const processedProducts = products.map(product => {
+ const category = categories.find((c) => c.id === product.categoryId);
+
+ // Formatear precio según si tiene variantes o no
+ let priceDisplay = "";
+ if (product.price) {
+ priceDisplay = `S/${product.price}`;
+ } else if (product.minPrice && product.maxPrice) {
+ priceDisplay = `S/${product.minPrice} - S/${product.maxPrice}`;
+ }
+
+ // Formatear variantes según el tipo
+ let variantDisplay = "";
+ if (product.variantAttributeValues && product.variantAttributeValues.length > 0) {
+ const variantType = product.variantAttributeValues[0]?.variantAttribute?.name;
+
+ switch (variantType) {
+ case 'talla': {
+ const sizes = product.variantAttributeValues.map((v: VariantAttributeValueWithNumber) => v.value).join(", ");
+ variantDisplay = `\n- 👕 Tallas disponibles: ${sizes}`;
+ break;
+ }
+ case 'dimensión': {
+ const dimensions = product.variantAttributeValues
+ .map((v: VariantAttributeValueWithNumber) => `${v.value} (S/${v.price})`)
+ .join(", ");
+ variantDisplay = `\n- 📐 Dimensiones: ${dimensions}`;
+ break;
+ }
+ default: {
+ const options = product.variantAttributeValues
+ .map((v: VariantAttributeValueWithNumber) => `${v.value} (S/${v.price})`)
+ .join(", ");
+ variantDisplay = `\n- ⚙️ Opciones: ${options}`;
+ }
+ }
+ }
+
+ return {
+ ...product,
+ categoryTitle: category?.title || "Sin categoría",
+ priceDisplay,
+ variantDisplay
+ };
+ });
+
+ // Procesar productos en oferta
+ const onSaleProducts = processedProducts.filter((p) => p.isOnSale);
+ const salesSection = onSaleProducts.length > 0
+ ? `
## 🔥 PRODUCTOS EN OFERTA ESPECIAL:
${onSaleProducts
- .map(
- (product) => `
-- **${product.title}** - S/${product.price} ⚡ [Ver oferta](/products/${product.id})
-`
- )
+ .map(product => `
+- **${product.title}** - ${product.priceDisplay} ⚡ [Ver oferta](/products/${product.id})`)
.join("")}
`
- : "";
+ : "";
+ // Procesar carrito del usuario
const cartSection = userCart?.items?.length
? `
## 🛒 CARRITO ACTUAL DEL USUARIO:
El usuario tiene actualmente ${userCart.items.length} producto(s) en su carrito:
${userCart.items
- .map(
- (item) => `
+ .map(item => `
- **${item.product.title}** (Cantidad: ${item.quantity}) - S/${item.product.price}
- Link: [Ver producto](/products/${item.product.id})
-`
- )
+ Link: [Ver producto](/products/${item.product.id})`)
.join("")}
**IMPORTANTE**: Usa esta información para hacer recomendaciones inteligentes:
@@ -48,9 +91,29 @@ ${userCart.items
- Evita recomendar productos que ya están en el carrito
- Ofrece bundles o combos cuando sea apropiado
- Menciona que puedes ver lo que ya tienen seleccionado y personalizar las sugerencias
+- Si en el carrito el usuario tiene un polo, recomienda un producto de la misma categoría y variante (talla) que la del polo presente en su carrito
`
: "";
+ // Generar categorías
+ const categoriesSection = categories
+ .map(cat => `
+**${cat.title}** (${cat.slug})
+- Descripción: ${cat.description}
+- Link: [Ver categoría](/category/${cat.slug})`)
+ .join("\n");
+
+ // Generar productos
+ const productsSection = processedProducts
+ .map(product => `
+**${product.title}**
+- 💰 Precio: ${product.priceDisplay}${product.isOnSale ? " ⚡ ¡EN OFERTA!" : ""}
+- 📝 Descripción: ${product.description}
+- 🏷️ Categoría: ${product.categoryTitle}
+- ✨ Características: ${product.features.join(", ")}${product.variantDisplay}
+- 🔗 Link: [Ver producto](/products/${product.id})`)
+ .join("\n");
+
return `
# Asistente Virtual de Full Stock
@@ -65,44 +128,48 @@ Eres un asistente virtual especializado en **Full Stock**, una tienda de product
- Si te preguntan sobre temas completamente no relacionados, redirige brevemente hacia los productos
- Usa un lenguaje natural y cercano, pero profesional
- Siempre termina con una pregunta directa o llamada a la acción
+- **EMPATIZA** con los problemas típicos de developers (debugging, deadlines, stack decisions)
+- **TONO**: Casual pero experto - como un desarrollador que entiende a otros developers
## PRODUCTOS DISPONIBLES:
### Categorías:
-${categories
- .map(
- (cat) => `
-**${cat.title}** (${cat.slug})
-- Descripción: ${cat.description}
-- Link: [Ver categoría](/category/${cat.slug})
-`
- )
- .join("\n")}
+${categoriesSection}
### Productos:
-${products
- .map((product) => {
- const category = categories.find((c) => c.id === product.categoryId);
- return `
-**${product.title}**
-- 💰 Precio: S/${product.price}${product.isOnSale ? " ⚡ ¡EN OFERTA!" : ""}
-- 📝 Descripción: ${product.description}
-- 🏷️ Categoría: ${category?.title || "Sin categoría"}
-- ✨ Características: ${product.features.join(", ")}
-- 🔗 Link: [Ver producto](/products/${product.id})
-`;
- })
- .join("\n")}
+${productsSection}
${salesSection}
${cartSection}
+## MANEJO DE VARIANTES DE PRODUCTOS:
+**IMPORTANTE**: Cuando un usuario muestre interés en un producto con variantes:
+
+### Para POLOS (Tallas):
+- Si preguntan por un polo, menciona: "¿Qué talla necesitas: Small, Medium o Large?"
+- Ejemplo: "¡El [Polo React](/products/1) está disponible en tallas Small, Medium y Large por S/20! ¿Cuál prefieres?"
+
+### Para STICKERS (Dimensiones):
+- Menciona las opciones con precios, es decir, menciona cada dimensión con su respectivo precio
+- Ejemplo: "¡El [Sticker Docker](/products/10) viene en varios tamaños! ¿Prefieres 3x3cm (S/2.99), 5x5cm (S/3.99) o 10x10cm (S/4.99)?"
+
+### Para PRODUCTOS ÚNICOS (Tazas):
+- Procede normal, no menciones variantes
+- Ejemplo: "¡La [Taza JavaScript](/products/18) por S/14.99 es perfecta para tu café matutino!"
+
+### Reglas Generales:
+- **SIEMPRE pregunta por la variante** cuando el usuario muestre interés en el producto
+- **Incluye precios** solo si varían entre opciones
+- **Sé específico** sobre las opciones disponibles
+- **Facilita la decisión** con recomendaciones si es necesario
+
## INSTRUCCIONES PARA RESPUESTAS:
- **MANTÉN LAS RESPUESTAS BREVES Y DIRECTAS** (máximo 2-3 oraciones)
- Ve directo al punto, sin explicaciones largas
- Cuando recomiendes productos, SIEMPRE incluye el link en formato: [Nombre del Producto](/products/ID)
- Para categorías, usa links como: [Categoría](/category/slug)
+- **AL MENCIONAR PRODUCTOS CON VARIANTES**, pregunta inmediatamente por la opción preferida
- Responde en **Markdown** para dar formato atractivo
- Sé específico sobre precios, características y beneficios
- Si hay productos en oferta, destácalos con emojis y texto llamativo
@@ -123,6 +190,9 @@ ${cartSection}
- **Personalización**: Adapta según el nivel o tecnología mencionada
- **Storytelling**: Usa curiosidades técnicas o historias para conectar emocionalmente con productos
- **Oportunidades educativas**: Si preguntan sobre tecnologías que tienes en productos, educa brevemente y conecta con la venta
+- **Variantes como valor**: Destaca las opciones disponibles como ventaja del producto
+- **Desinterés**: Si el usuario muestra desinterés, ofrece alternativas o pregunta sobre sus necesidades específicas
+- **Regla de variante automática**: Si el usuario muestra interés en un un polo, siempre pregunta automáticamente por la talla (Small, Medium o Large) del usuario
## LÓGICA DE RECOMENDACIONES BASADAS EN CARRITO:
**Si el usuario tiene productos en su carrito y pide recomendaciones:**
@@ -144,17 +214,19 @@ Cuando te pregunten sobre tecnologías que tenemos en productos (React, Docker,
4. **Ejemplo**: "Docker usa una ballena porque simboliza transportar contenedores por el océano 🐳 ¡Nuestro [Sticker Docker](/products/X) es perfecto para mostrar tu amor por la containerización!"
## RESPUESTAS A PREGUNTAS COMUNES:
-- **Tallas**: "Nuestros polos vienen en tallas S, M, L, XL. ¿Cuál prefieres?"
+- **Tallas**: "Nuestros polos vienen en tallas Small, Medium, Large. ¿Cuál prefieres?"
+- **Dimensiones**: "Nuestros stickers vienen en 3 dimensiones distintas, 3x3 cm, 5x5 cm y 10x10 cm. ¿Cuál sería la mejor para ti?"
- **Envío**: "Manejamos envío a todo el país. ¿A qué ciudad lo necesitas?"
- **Materiales**: "Usamos algodón 100% de alta calidad para máxima comodidad"
- **Cuidado**: "Para que dure más, lava en agua fría y evita la secadora"
-## EJEMPLOS DE RESPUESTAS CORTAS:
-- "¡Te recomiendo el [Polo React](/products/1) por S/20.00! 🚀 ¿Qué talla necesitas?"
-- "Perfecto para backend: [Polo Backend Developer](/products/3) ⚡ **EN OFERTA** por S/25.00. ¿Te animas?"
-- **Ejemplo de pregunta técnica relacionada**: "¡La ballena de Docker representa la facilidad de transportar aplicaciones! 🐳 Nuestro [Sticker Docker](/products/X) captura perfectamente esa filosofía. ¿Te gusta coleccionar stickers de tecnología?"
-- **Ejemplo con carrito (React)**: "Veo que tienes el Polo React en tu carrito! Para completar tu look frontend, te recomiendo la [Taza React](/products/Y). ¿Te interesa?"
-- **Ejemplo con carrito (Backend)**: "Perfecto, tienes productos backend en tu carrito. El [Sticker Node.js](/products/Z) combinaría genial. ¿Lo agregamos?"
+## EJEMPLOS DE RESPUESTAS CORTAS CON VARIANTES:
+- "¡Te recomiendo el [Polo React](/products/1) por S/20! 🚀 ¿Qué talla necesitas: Small, Medium o Large?"
+- "La [Taza Docker](/products/2) por S/14.99 es ideal para tus momentos de café. ¿La agregamos?"
+
+- "La [Taza JavaScript](/products/18) por S/14.99 es perfecta para programar. ¿La agregamos?"
+- **Ejemplo con carrito (React)**: "Veo que tienes el Polo React! Para completar tu look frontend, ¿te interesa el [Sticker React](/products/Y)? Viene en 3 tamaños diferentes."
+- **Ejemplo con carrito (Backend)**: "Perfecto, tienes productos backend. El [Polo Node.js](/products/Z) combinaría genial. ¿Qué talla usas: Small, Medium o Large?"
¿En qué puedo ayudarte hoy a encontrar el producto perfecto para ti? 🛒✨
`;
diff --git a/src/services/order.service.test.ts b/src/services/order.service.test.ts
index f5ffa51..640ee65 100644
--- a/src/services/order.service.test.ts
+++ b/src/services/order.service.test.ts
@@ -1,4 +1,5 @@
-import { describe, expect, it, vi } from "vitest";
+import { Decimal } from "@prisma/client/runtime/library";
+import { describe, expect, it, vi, beforeEach } from "vitest";
import { prisma as mockPrisma } from "@/db/prisma";
import { calculateTotal } from "@/lib/cart";
@@ -11,7 +12,7 @@ import {
createTestRequest,
createTestUser,
} from "@/lib/utils.tests";
-import type { CartItemInput } from "@/models/cart.model";
+import type { CartItemWithProduct } from "@/models/cart.model";
import { getSession } from "@/session.server";
import { createOrder, getOrdersByUser } from "./order.service";
@@ -31,20 +32,34 @@ vi.mock("@/lib/cart");
vi.mock("@/session.server");
describe("Order Service", () => {
- const mockedItems: CartItemInput[] = [
+ beforeEach(() => {
+ vi.clearAllMocks();
+ });
+
+ const mockedItems: CartItemWithProduct[] = [
{
- productId: 1,
+ product: {
+ id: 1,
+ title: "Test Product",
+ price: 19.99,
+ imgSrc: "test-product.jpg",
+ alt: "Test Product Alt",
+ isOnSale: false,
+ },
quantity: 2,
- title: "Test Product",
- price: 19.99,
- imgSrc: "test-product.jpg",
+ attributeValueId: 1,
},
{
- productId: 2,
+ product: {
+ id: 2,
+ title: "Another Product",
+ price: 29.99,
+ imgSrc: "another-product.jpg",
+ alt: "Another Product Alt",
+ isOnSale: true,
+ },
quantity: 1,
- title: "Another Product",
- price: 29.99,
- imgSrc: "another-product.jpg",
+ attributeValueId: 2,
},
];
@@ -53,61 +68,105 @@ describe("Order Service", () => {
const mockedTotalAmount = 200;
const mockedRequest = createTestRequest();
- it("should create an order", async () => {
- const prismaOrder = {
- ...createTestDBOrder(),
- items: [createTestDBOrderItem()],
- };
-
- vi.mocked(getOrCreateUser).mockResolvedValue(mockedUser);
- vi.mocked(calculateTotal).mockReturnValue(mockedTotalAmount);
-
- vi.mocked(mockPrisma.order.create).mockResolvedValue(prismaOrder);
-
- const order = await createOrder(mockedItems, mockedFormData, "payment-id");
- expect(mockPrisma.order.create).toHaveBeenCalledWith({
- data: {
- userId: mockedUser.id,
- totalAmount: mockedTotalAmount,
- email: mockedFormData.email,
- firstName: mockedFormData.firstName,
- lastName: mockedFormData.lastName,
- company: mockedFormData.company,
- address: mockedFormData.address,
- city: mockedFormData.city,
- country: mockedFormData.country,
- region: mockedFormData.region,
- zip: mockedFormData.zip,
- phone: mockedFormData.phone,
- items: {
- create: mockedItems.map((item) => ({
- productId: item.productId,
- quantity: item.quantity,
- title: item.title,
- price: item.price,
- imgSrc: item.imgSrc,
- })),
+ describe("createOrder", () => {
+ it("should create an order successfully", async () => {
+ const prismaOrder = {
+ ...createTestDBOrder(),
+ items: [
+ {
+ ...createTestDBOrderItem(),
+ variantAttributeValue: {
+ id: 1,
+ value: "Test Value",
+ price: 19.99,
+ product: {
+ id: 1,
+ title: "Test Product",
+ imgSrc: "test-product.jpg",
+ alt: "Test Product Alt",
+ isOnSale: false,
+ },
+ },
+ },
+ ],
+ };
+
+ vi.mocked(getOrCreateUser).mockResolvedValue(mockedUser);
+ vi.mocked(calculateTotal).mockReturnValue(mockedTotalAmount);
+ vi.mocked(mockPrisma.order.create).mockResolvedValue(prismaOrder);
+
+ const order = await createOrder(mockedItems, mockedFormData, "payment-id");
+
+ expect(getOrCreateUser).toHaveBeenCalledWith(mockedFormData.email);
+ expect(calculateTotal).toHaveBeenCalledWith(mockedItems);
+ expect(mockPrisma.order.create).toHaveBeenCalledWith({
+ data: {
+ userId: mockedUser.id,
+ totalAmount: mockedTotalAmount,
+ email: mockedFormData.email,
+ firstName: mockedFormData.firstName,
+ lastName: mockedFormData.lastName,
+ company: mockedFormData.company,
+ address: mockedFormData.address,
+ city: mockedFormData.city,
+ country: mockedFormData.country,
+ region: mockedFormData.region,
+ zip: mockedFormData.zip,
+ phone: mockedFormData.phone,
+ items: {
+ create: mockedItems.map((item) => ({
+ attributeValueId: item.attributeValueId,
+ quantity: item.quantity,
+ title: item.product.title,
+ price: item.product.price ?? 0,
+ imgSrc: item.product.imgSrc ?? "",
+ })),
+ },
+ paymentId: "payment-id",
+ },
+ include: {
+ items: {
+ include: {
+ variantAttributeValue: {
+ include: {
+ product: {
+ select: {
+ id: true,
+ title: true,
+ imgSrc: true,
+ alt: true,
+ isOnSale: true,
+ },
+ },
+ },
+ },
+ },
+ },
+ },
+ });
+
+ expect(order).toEqual({
+ ...prismaOrder,
+ totalAmount: Number(prismaOrder.totalAmount),
+ items: prismaOrder.items.map((item) => ({
+ ...item,
+ price: Number(item.price),
+ variantAttributeValue: item.variantAttributeValue,
+ })),
+ createdAt: prismaOrder.createdAt,
+ updatedAt: prismaOrder.updatedAt,
+ details: {
+ email: prismaOrder.email,
+ firstName: prismaOrder.firstName,
+ lastName: prismaOrder.lastName,
+ company: prismaOrder.company,
+ address: prismaOrder.address,
+ city: prismaOrder.city,
+ country: prismaOrder.country,
+ region: prismaOrder.region,
+ zip: prismaOrder.zip,
+ phone: prismaOrder.phone,
},
- paymentId: "payment-id",
- },
- include: {
- items: true,
- },
- });
- expect(order).toEqual({
- ...prismaOrder,
- totalAmount: Number(prismaOrder.totalAmount),
- items: prismaOrder.items.map((item) => ({
- ...item,
- price: Number(item.price),
- imgSrc: item.imgSrc ?? "",
- productId: item.productId ?? 0,
- createdAt: item.createdAt,
- updatedAt: item.updatedAt,
- })),
- createdAt: prismaOrder.createdAt,
- updatedAt: prismaOrder.updatedAt,
- details: {
email: prismaOrder.email,
firstName: prismaOrder.firstName,
lastName: prismaOrder.lastName,
@@ -118,43 +177,141 @@ describe("Order Service", () => {
region: prismaOrder.region,
zip: prismaOrder.zip,
phone: prismaOrder.phone,
- },
- paymentId: prismaOrder.paymentId,
+ paymentId: prismaOrder.paymentId,
+ });
});
- });
- it("should get orders by user", async () => {
- const prismaOrders = [
- { ...createTestDBOrder(), items: [createTestOrderItem()] },
- {
- ...createTestDBOrder({ id: 2 }),
- items: [createTestOrderItem({ id: 2 })],
- },
- ];
- const mockedSession = createMockSession(mockedUser.id);
- vi.mocked(getSession).mockResolvedValue(mockedSession);
- vi.mocked(mockPrisma.order.findMany).mockResolvedValue(prismaOrders);
- const orders = await getOrdersByUser(mockedRequest);
- expect(mockPrisma.order.findMany).toHaveBeenCalledWith({
- where: { userId: mockedUser.id },
- include: { items: true },
- orderBy: { createdAt: "desc" },
+ it("should throw error if order creation fails", async () => {
+ vi.mocked(getOrCreateUser).mockResolvedValue(mockedUser);
+ vi.mocked(calculateTotal).mockReturnValue(mockedTotalAmount);
+ vi.mocked(mockPrisma.order.create).mockRejectedValue(
+ new Error("Database error")
+ );
+
+ await expect(
+ createOrder(mockedItems, mockedFormData, "payment-id")
+ ).rejects.toThrow("Failed to create order");
+
+ expect(mockPrisma.order.create).toHaveBeenCalled();
});
- expect(orders).toEqual(
- prismaOrders.map((order) => ({
- ...order,
- totalAmount: Number(order.totalAmount),
- items: order.items.map((item) => ({
- ...item,
- price: Number(item.price),
- imgSrc: item.imgSrc ?? "",
- productId: item.productId ?? 0,
- createdAt: item.createdAt,
- updatedAt: item.updatedAt,
- })),
- createdAt: order.createdAt,
- updatedAt: order.updatedAt,
- details: {
+
+ it("should handle empty items array", async () => {
+ vi.mocked(getOrCreateUser).mockResolvedValue(mockedUser);
+ vi.mocked(calculateTotal).mockReturnValue(0);
+
+ const prismaOrder = {
+ ...createTestDBOrder({ totalAmount: new Decimal(0) }),
+ items: [],
+ };
+
+ vi.mocked(mockPrisma.order.create).mockResolvedValue(prismaOrder);
+
+ const order = await createOrder([], mockedFormData, "payment-id");
+
+ expect(order.items).toEqual([]);
+ expect(order.totalAmount).toBe(0);
+ });
+ });
+
+ describe("getOrdersByUser", () => {
+ it("should get orders by user successfully", async () => {
+ const prismaOrders = [
+ {
+ ...createTestDBOrder(),
+ items: [
+ {
+ ...createTestOrderItem(),
+ variantAttributeValue: {
+ id: 1,
+ value: "Test Value",
+ price: 19.99,
+ product: {
+ id: 1,
+ title: "Test Product",
+ imgSrc: "test-product.jpg",
+ alt: "Test Product Alt",
+ isOnSale: false,
+ },
+ },
+ },
+ ],
+ },
+ {
+ ...createTestDBOrder({ id: 2 }),
+ items: [
+ {
+ ...createTestOrderItem({ id: 2 }),
+ variantAttributeValue: {
+ id: 2,
+ value: "Test Value 2",
+ price: 29.99,
+ product: {
+ id: 2,
+ title: "Another Product",
+ imgSrc: "another-product.jpg",
+ alt: "Another Product Alt",
+ isOnSale: true,
+ },
+ },
+ },
+ ],
+ },
+ ];
+ const mockedSession = createMockSession(mockedUser.id);
+
+ vi.mocked(getSession).mockResolvedValue(mockedSession);
+ vi.mocked(mockPrisma.order.findMany).mockResolvedValue(prismaOrders);
+
+ const orders = await getOrdersByUser(mockedRequest);
+
+ expect(getSession).toHaveBeenCalledWith("session=mock-session-id");
+ expect(mockPrisma.order.findMany).toHaveBeenCalledWith({
+ where: { userId: mockedUser.id },
+ include: {
+ items: {
+ include: {
+ variantAttributeValue: {
+ include: {
+ product: {
+ select: {
+ id: true,
+ title: true,
+ imgSrc: true,
+ alt: true,
+ isOnSale: true,
+ },
+ },
+ },
+ },
+ },
+ },
+ },
+ orderBy: { createdAt: "desc" },
+ });
+
+ expect(orders).toEqual(
+ prismaOrders.map((order) => ({
+ ...order,
+ totalAmount: Number(order.totalAmount),
+ items: order.items.map((item) => ({
+ ...item,
+ price: Number(item.price),
+ variantAttributeValue: item.variantAttributeValue,
+ })),
+ createdAt: order.createdAt,
+ updatedAt: order.updatedAt,
+ details: {
+ email: order.email,
+ firstName: order.firstName,
+ lastName: order.lastName,
+ company: order.company,
+ address: order.address,
+ city: order.city,
+ country: order.country,
+ region: order.region,
+ zip: order.zip,
+ phone: order.phone,
+ },
email: order.email,
firstName: order.firstName,
lastName: order.lastName,
@@ -165,34 +322,68 @@ describe("Order Service", () => {
region: order.region,
zip: order.zip,
phone: order.phone,
- },
- }))
- );
- });
+ }))
+ );
+ });
- it("should throw error if user is not authenticated", async () => {
- const mockedSession = createMockSession(null);
+ it("should throw error if user is not authenticated", async () => {
+ const mockedSession = createMockSession(null);
- vi.mocked(getSession).mockResolvedValue(mockedSession);
+ vi.mocked(getSession).mockResolvedValue(mockedSession);
- await expect(getOrdersByUser(mockedRequest)).rejects.toThrow(
- "User not authenticated"
- );
+ await expect(getOrdersByUser(mockedRequest)).rejects.toThrow(
+ "User not authenticated"
+ );
- expect(getSession).toHaveBeenCalledWith("session=mock-session-id");
- });
+ expect(getSession).toHaveBeenCalledWith("session=mock-session-id");
+ expect(mockPrisma.order.findMany).not.toHaveBeenCalled();
+ });
+
+ it("should return empty array if user has no orders", async () => {
+ const mockedSession = createMockSession(mockedUser.id);
- it("should throw error if order creation fails", async () => {
- vi.mocked(getOrCreateUser).mockResolvedValue(mockedUser);
- vi.mocked(calculateTotal).mockReturnValue(mockedTotalAmount);
- vi.mocked(mockPrisma.order.create).mockRejectedValue(
- new Error("Database error")
- );
+ vi.mocked(getSession).mockResolvedValue(mockedSession);
+ vi.mocked(mockPrisma.order.findMany).mockResolvedValue([]);
- await expect(
- createOrder(mockedItems, mockedFormData, "payment-id")
- ).rejects.toThrow("Failed to create order");
+ const orders = await getOrdersByUser(mockedRequest);
- expect(mockPrisma.order.create).toHaveBeenCalled();
+ expect(orders).toEqual([]);
+ expect(mockPrisma.order.findMany).toHaveBeenCalledWith({
+ where: { userId: mockedUser.id },
+ include: {
+ items: {
+ include: {
+ variantAttributeValue: {
+ include: {
+ product: {
+ select: {
+ id: true,
+ title: true,
+ imgSrc: true,
+ alt: true,
+ isOnSale: true,
+ },
+ },
+ },
+ },
+ },
+ },
+ },
+ orderBy: { createdAt: "desc" },
+ });
+ });
+
+ it("should handle database errors gracefully", async () => {
+ const mockedSession = createMockSession(mockedUser.id);
+
+ vi.mocked(getSession).mockResolvedValue(mockedSession);
+ vi.mocked(mockPrisma.order.findMany).mockRejectedValue(
+ new Error("Database connection error")
+ );
+
+ await expect(getOrdersByUser(mockedRequest)).rejects.toThrow(
+ "Failed to fetch orders"
+ );
+ });
});
-});
+});
\ No newline at end of file
diff --git a/src/services/order.service.ts b/src/services/order.service.ts
index 6f5948a..1592c6e 100644
--- a/src/services/order.service.ts
+++ b/src/services/order.service.ts
@@ -1,13 +1,13 @@
import { prisma } from "@/db/prisma";
import { calculateTotal } from "@/lib/cart";
-import { type CartItemInput } from "@/models/cart.model";
+import { type CartItemWithProduct } from "@/models/cart.model";
import { type Order, type OrderDetails } from "@/models/order.model";
import { getSession } from "@/session.server";
import { getOrCreateUser } from "./user.service";
export async function createOrder(
- items: CartItemInput[],
+ items: CartItemWithProduct[],
formData: OrderDetails,
paymentId: string
): Promise {
@@ -25,17 +25,33 @@ export async function createOrder(
...shippingDetails,
items: {
create: items.map((item) => ({
- productId: item.productId,
+ attributeValueId: item.attributeValueId,
quantity: item.quantity,
- title: item.title,
- price: item.price,
- imgSrc: item.imgSrc,
+ title: item.product.title,
+ price: item.product.price ?? 0,
+ imgSrc: item.product.imgSrc ?? "",
})),
},
paymentId: paymentId,
},
include: {
- items: true,
+ items: {
+ include: {
+ variantAttributeValue: {
+ include: {
+ product: {
+ select: {
+ id: true,
+ title: true,
+ imgSrc: true,
+ alt: true,
+ isOnSale: true,
+ },
+ },
+ },
+ },
+ },
+ },
},
});
} catch (error) {
@@ -54,16 +70,14 @@ export async function createOrder(
zip: order.zip,
phone: order.phone,
};
+
return {
...order,
totalAmount: Number(order.totalAmount),
items: order.items.map((item) => ({
...item,
price: Number(item.price),
- imgSrc: item.imgSrc,
- productId: item.productId,
- createdAt: item.createdAt,
- updatedAt: item.updatedAt,
+ variantAttributeValue: item.variantAttributeValue,
})),
createdAt: order.createdAt,
updatedAt: order.updatedAt,
@@ -78,15 +92,39 @@ export async function getOrdersByUser(request: Request): Promise {
if (!userId) {
throw new Error("User not authenticated");
}
- const orders = await prisma.order.findMany({
- where: { userId },
- include: {
- items: true,
- },
- orderBy: {
- createdAt: "desc",
- },
- });
+
+ let orders;
+
+ try {
+ orders = await prisma.order.findMany({
+ where: { userId },
+ include: {
+ items: {
+ include: {
+ variantAttributeValue: {
+ include: {
+ product: {
+ select: {
+ id: true,
+ title: true,
+ imgSrc: true,
+ alt: true,
+ isOnSale: true,
+ },
+ },
+ },
+ },
+ },
+ },
+ },
+ orderBy: {
+ createdAt: "desc",
+ },
+ });
+ } catch (error) {
+ throw new Error("Failed to fetch orders", { cause: error });
+ }
+
return orders.map((order) => {
const details = {
email: order.email,
@@ -100,14 +138,14 @@ export async function getOrdersByUser(request: Request): Promise {
zip: order.zip,
phone: order.phone,
};
+
return {
...order,
totalAmount: Number(order.totalAmount),
items: order.items.map((item) => ({
...item,
price: Number(item.price),
- createdAt: item.createdAt,
- updatedAt: item.updatedAt,
+ variantAttributeValue: item.variantAttributeValue,
})),
createdAt: order.createdAt,
updatedAt: order.updatedAt,
@@ -115,4 +153,4 @@ export async function getOrdersByUser(request: Request): Promise {
...details,
};
});
-}
+}
\ No newline at end of file
diff --git a/src/services/product.service.test.ts b/src/services/product.service.test.ts
index 7bac27a..7da50a3 100644
--- a/src/services/product.service.test.ts
+++ b/src/services/product.service.test.ts
@@ -1,13 +1,19 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { vi, describe, it, expect, beforeEach } from "vitest";
+
import { prisma as mockPrisma } from "@/db/prisma";
-import { createTestCategory, createTestDBProduct } from "@/lib/utils.tests";
-import type { Category } from "@/models/category.model";
+import {
+ createTestCategory,
+ createTestDBProduct,
+ createTestDBVariantAttributeValue,
+} from "@/lib/utils.tests";
import { getCategoryBySlug } from "./category.service";
-import { getProductById, getProductsByCategorySlug } from "./product.service";
+import { getProductsByCategorySlug, getProductById, formattedProduct } from "./product.service";
+
+import type { Category } from "generated/prisma/client";
-import type { Product as PrismaProduct } from "@/../generated/prisma/client";
+import { Decimal } from "@/../generated/prisma/internal/prismaNamespace";
vi.mock("@/db/prisma", () => ({
prisma: {
@@ -18,7 +24,6 @@ vi.mock("@/db/prisma", () => ({
},
}));
-// Mock category service
vi.mock("./category.service");
describe("Product Service", () => {
@@ -27,93 +32,79 @@ describe("Product Service", () => {
});
describe("getProductsByCategorySlug", () => {
- it("should return products for a valid category slug", async () => {
- // Step 1: Setup - Create test data with valid category and products
+ it("should return products for a valid category slug with prices as numbers", async () => {
const testCategory = createTestCategory();
- const mockedProducts: PrismaProduct[] = [
+
+ const mockedProducts = [
createTestDBProduct({ id: 1, categoryId: testCategory.id }),
- createTestDBProduct({
- id: 2,
- title: "Test Product 2",
- categoryId: testCategory.id,
- }),
+ createTestDBProduct({ id: 2, categoryId: testCategory.id }),
];
- // Step 2: Mock - Configure responses
vi.mocked(getCategoryBySlug).mockResolvedValue(testCategory);
-
vi.mocked(mockPrisma.product.findMany).mockResolvedValue(mockedProducts);
- // Step 3: Call service function
const products = await getProductsByCategorySlug(testCategory.slug);
- // Step 4: Verify expected behavior
expect(getCategoryBySlug).toHaveBeenCalledWith(testCategory.slug);
expect(mockPrisma.product.findMany).toHaveBeenCalledWith({
where: { categoryId: testCategory.id },
+ include: { variantAttributeValues: true },
});
+
+ // Comprobamos que los precios se transforman a number
expect(products).toEqual(
- mockedProducts.map((product) => ({
- ...product,
- price: product.price.toNumber(),
- }))
+ mockedProducts.map(formattedProduct)
);
});
-
it("should throw error when category slug does not exist", async () => {
- // Step 1: Setup - Create test data for non-existent category
const invalidSlug = "invalid-slug";
-
- // Step 2: Mock - Configure error response
const errorMessage = `Category with slug "${invalidSlug}" not found`;
- vi.mocked(getCategoryBySlug).mockRejectedValue(new Error(errorMessage));
- // Step 3: Call service function
- const getProducts = getProductsByCategorySlug(
- invalidSlug as Category["slug"]
- );
+ vi.mocked(getCategoryBySlug).mockRejectedValue(new Error(errorMessage));
- // Step 4: Verify expected behavior
- await expect(getProducts).rejects.toThrow(errorMessage);
+ await expect(getProductsByCategorySlug(invalidSlug as Category["slug"])).rejects.toThrow(errorMessage);
expect(mockPrisma.product.findMany).not.toHaveBeenCalled();
});
});
describe("getProductById", () => {
- it("should return product for valid ID", async () => {
- // Step 1: Setup - Create test data for existing product
- const testProduct = createTestDBProduct();
+ it("should return product for valid ID with prices as numbers", async () => {
+ const testProduct = createTestDBProduct({
+ id: 1,
+ variantAttributeValues: [
+ createTestDBVariantAttributeValue({ price: new Decimal(120) }),
+ createTestDBVariantAttributeValue({ id: 2, price: new Decimal(150) }),
+ ],
+ });
- // Step 2: Mock - Configure Prisma response
vi.mocked(mockPrisma.product.findUnique).mockResolvedValue(testProduct);
- // Step 3: Call service function
const result = await getProductById(testProduct.id);
- // Step 4: Verify expected behavior
expect(mockPrisma.product.findUnique).toHaveBeenCalledWith({
where: { id: testProduct.id },
+ include: { variantAttributeValues: { include: { variantAttribute: true } } },
});
+
+ // Se espera que el producto devuelto tenga minPrice y maxPrice correctamente calculados
expect(result).toEqual({
...testProduct,
- price: testProduct.price.toNumber(),
+ variantAttributeValues: testProduct.variantAttributeValues.map((v) => ({
+ ...v,
+ price: v.price.toNumber(),
+ })),
});
});
it("should throw error when product does not exist", async () => {
- // Step 1: Setup - Configure ID for non-existent product
const nonExistentId = 999;
- // Step 2: Mock - Configure null response from Prisma
vi.mocked(mockPrisma.product.findUnique).mockResolvedValue(null);
- // Step 3: Call service function
- const productPromise = getProductById(nonExistentId);
-
- // Step 4: Verify expected behavior
- await expect(productPromise).rejects.toThrow("Product not found");
+ await expect(getProductById(nonExistentId)).rejects.toThrow("Product not found");
expect(mockPrisma.product.findUnique).toHaveBeenCalledWith({
where: { id: nonExistentId },
+ include: { variantAttributeValues: { include: { variantAttribute: true } } },
});
});
});
diff --git a/src/services/product.service.ts b/src/services/product.service.ts
index 3406570..983a43d 100644
--- a/src/services/product.service.ts
+++ b/src/services/product.service.ts
@@ -1,38 +1,107 @@
import { prisma } from "@/db/prisma";
import type { Category } from "@/models/category.model";
-import type { Product } from "@/models/product.model";
+import type { Product, ProductDTO } from "@/models/product.model";
+import type { VariantAttributeValue } from "@/models/variant-attribute.model";
import { getCategoryBySlug } from "./category.service";
+export const formattedProduct = (product: ProductDTO): Product => {
+ const { variantAttributeValues, ...rest } = product;
+ const prices = variantAttributeValues.map((v: VariantAttributeValue) =>
+ v.price.toNumber()
+ );
+ const minPrice = Math.min(...prices);
+ const maxPrice = Math.max(...prices);
+ if (minPrice === maxPrice) {
+ return {
+ ...rest,
+ price: minPrice,
+ };
+ }
+ return {
+ ...rest,
+ minPrice,
+ maxPrice,
+ };
+};
+
export async function getProductsByCategorySlug(
categorySlug: Category["slug"]
): Promise {
const category = await getCategoryBySlug(categorySlug);
const products = await prisma.product.findMany({
where: { categoryId: category.id },
+ include: {
+ variantAttributeValues: true,
+ },
});
- return products.map((product) => ({
- ...product,
- price: product.price.toNumber(),
- }));
+ return products.map(formattedProduct);
}
export async function getProductById(id: number): Promise {
const product = await prisma.product.findUnique({
where: { id },
+ include: {
+ variantAttributeValues: {
+ include: {
+ variantAttribute: true,
+ },
+ },
+ },
});
-
if (!product) {
throw new Error("Product not found");
}
+ const productWithParsedPrices = {
+ ...product,
+ variantAttributeValues: product.variantAttributeValues.map((variant) => ({
+ ...variant,
+ price: variant.price.toNumber(),
+ })),
+ };
- return { ...product, price: product.price.toNumber() };
+ return productWithParsedPrices as unknown as Product;
}
export async function getAllProducts(): Promise {
- return (await prisma.product.findMany()).map((p) => ({
- ...p,
- price: p.price.toNumber(),
- }));
+ const products = await prisma.product.findMany({
+ include: {
+ variantAttributeValues: true,
+ },
+ });
+ return products.map(formattedProduct);
}
+
+export async function filterByMinMaxPrice(
+ slug: string,
+ min?: number,
+ max?: number
+): Promise {
+ const priceFilter: { gte?: number; lte?: number } = {};
+
+ if (min !== undefined) {
+ priceFilter.gte = min;
+ }
+ if (max !== undefined) {
+ priceFilter.lte = max;
+ }
+
+ const result = await prisma.product.findMany({
+ where: {
+ category: {
+ slug: slug as Category["slug"], // si slug es enum
+ },
+ variantAttributeValues: {
+ some: {
+ price: priceFilter, // 👈 el rango se aplica al mismo variant
+ },
+ },
+ },
+ include: {
+ variantAttributeValues: true,
+ },
+ });
+
+ return result.map(formattedProduct);
+}
\ No newline at end of file
- 
-