kybernus 3.0.1 → 3.2.0

package/templates/ecommerce/apps/api/src/modules/cart/__tests__/cart.routes.integration.test.ts

@@ -0,0 +1,242 @@
+import request from 'supertest';
+import app from '../../../app';
+
+/**
+ * Integration tests for Cart routes.
+ * Uses in-memory repositories via the cart.registry module.
+ */
+
+let customerToken: string;
+let adminToken: string;
+let productId: string;
+let variantId: string;
+
+const CUSTOMER_USER = {
+  name: 'Cart Customer',
+  email: 'cart.customer@ecommerce.com',
+  password: 'cartpass123',
+};
+
+const ADMIN_USER = {
+  name: 'Cart Admin',
+  email: 'cart.admin@ecommerce.com',
+  password: 'adminpass123',
+};
+
+beforeAll(async () => {
+  // Register customer
+  await request(app).post('/api/auth/register').send(CUSTOMER_USER);
+
+  // Create admin via registry
+  const { userRepository } = await import('../../auth/auth.registry');
+  const { UserEntity } = await import('../../auth/user.entity');
+  const { hash } = await import('bcryptjs');
+  const adminHash = await hash(ADMIN_USER.password, 10);
+  const adminEntity = UserEntity.create({
+    name: ADMIN_USER.name,
+    email: ADMIN_USER.email,
+    passwordHash: adminHash,
+    role: 'ADMIN',
+  });
+  await userRepository.create(adminEntity);
+
+  // Login both
+  const customerRes = await request(app).post('/api/auth/login').send({
+    email: CUSTOMER_USER.email,
+    password: CUSTOMER_USER.password,
+  });
+  customerToken = (customerRes.body as { accessToken: string }).accessToken;
+
+  const adminRes = await request(app).post('/api/auth/login').send({
+    email: ADMIN_USER.email,
+    password: ADMIN_USER.password,
+  });
+  adminToken = (adminRes.body as { accessToken: string }).accessToken;
+
+  // Create a product+variant via catalog API for cart tests
+  const { catalogRegistry } = await import('../../catalog/catalog.registry');
+  const { CategoryEntity } = await import('../../catalog/category.entity');
+  await catalogRegistry.categoryRepository.create(
+    CategoryEntity.create({ name: 'Cart Test', slug: 'cart-test', description: null, parentId: null }),
+  );
+
+  const productRes = await request(app)
+    .post('/api/products')
+    .set('Authorization', `Bearer ${adminToken}`)
+    .send({
+      name: 'Produto do Carrinho',
+      price: 99.9,
+      categorySlug: 'cart-test',
+      images: [],
+      variants: [{ sku: 'CART-P', size: 'P', color: 'Azul', stock: 10 }],
+    });
+  const body = productRes.body as { id: string; variants: Array<{ id: string }> };
+  productId = body.id;
+  variantId = body.variants[0]!.id;
+});
+
+// ── GET /api/cart ─────────────────────────────────────────────────────────────
+describe('GET /api/cart', () => {
+  it('200: deve retornar carrinho vazio se não existir', async () => {
+    const res = await request(app)
+      .get('/api/cart')
+      .set('Authorization', `Bearer ${customerToken}`);
+
+    expect(res.status).toBe(200);
+    expect(res.body).toMatchObject({ items: [], subtotal: 0, discount: 0, total: 0 });
+  });
+
+  it('401: deve exigir autenticação', async () => {
+    const res = await request(app).get('/api/cart');
+    expect(res.status).toBe(401);
+  });
+});
+
+// ── POST /api/cart/items ──────────────────────────────────────────────────────
+describe('POST /api/cart/items', () => {
+  it('201: deve adicionar item ao carrinho', async () => {
+    const res = await request(app)
+      .post('/api/cart/items')
+      .set('Authorization', `Bearer ${customerToken}`)
+      .send({ productId, variantId, qty: 2 });
+
+    expect(res.status).toBe(201);
+    expect(res.body.items).toHaveLength(1);
+    expect(res.body.items[0].qty).toBe(2);
+    expect(res.body.subtotal).toBeCloseTo(199.8, 1);
+  });
+
+  it('400: deve rejeitar quantidade <= 0', async () => {
+    const res = await request(app)
+      .post('/api/cart/items')
+      .set('Authorization', `Bearer ${customerToken}`)
+      .send({ productId, variantId, qty: 0 });
+
+    expect(res.status).toBe(400);
+  });
+
+  it('409: deve retornar erro se estoque insuficiente', async () => {
+    const res = await request(app)
+      .post('/api/cart/items')
+      .set('Authorization', `Bearer ${customerToken}`)
+      .send({ productId, variantId, qty: 9999 });
+
+    expect(res.status).toBe(409);
+  });
+});
+
+// ── PATCH /api/cart/items/:variantId ──────────────────────────────────────────
+describe('PATCH /api/cart/items/:variantId', () => {
+  it('200: deve atualizar quantidade do item', async () => {
+    const res = await request(app)
+      .patch(`/api/cart/items/${variantId}`)
+      .set('Authorization', `Bearer ${customerToken}`)
+      .send({ qty: 3 });
+
+    expect(res.status).toBe(200);
+    expect(res.body.items[0].qty).toBe(3);
+  });
+
+  it('deve remover item automaticamente se quantidade = 0', async () => {
+    const res = await request(app)
+      .patch(`/api/cart/items/${variantId}`)
+      .set('Authorization', `Bearer ${customerToken}`)
+      .send({ qty: 0 });
+
+    expect(res.status).toBe(200);
+    expect(res.body.items).toHaveLength(0);
+  });
+});
+
+// Re-add item for remaining tests
+let secondVariantId: string;
+
+beforeAll(async () => {
+  // Add item back after the update-to-zero test removes it
+  // Also grab a second variantId for DELETE test isolation
+  secondVariantId = variantId; // reuse for simplicity
+});
+
+// ── DELETE /api/cart/items/:variantId ─────────────────────────────────────────
+describe('DELETE /api/cart/items/:variantId', () => {
+  it('204: deve remover item', async () => {
+    // First add item back
+    await request(app)
+      .post('/api/cart/items')
+      .set('Authorization', `Bearer ${customerToken}`)
+      .send({ productId, variantId, qty: 1 });
+
+    const res = await request(app)
+      .delete(`/api/cart/items/${variantId}`)
+      .set('Authorization', `Bearer ${customerToken}`);
+
+    expect(res.status).toBe(204);
+
+    const cart = await request(app)
+      .get('/api/cart')
+      .set('Authorization', `Bearer ${customerToken}`);
+    expect((cart.body as { items: unknown[] }).items).toHaveLength(0);
+  });
+});
+
+// ── POST /api/cart/coupon ─────────────────────────────────────────────────────
+describe('POST /api/cart/coupon', () => {
+  it('200: deve aplicar cupom válido e retornar total atualizado', async () => {
+    // Add item first
+    await request(app)
+      .post('/api/cart/items')
+      .set('Authorization', `Bearer ${customerToken}`)
+      .send({ productId, variantId, qty: 1 });
+
+    const res = await request(app)
+      .post('/api/cart/coupon')
+      .set('Authorization', `Bearer ${customerToken}`)
+      .send({ code: 'PROMO10' });
+
+    expect(res.status).toBe(200);
+    expect(res.body.discount).toBeGreaterThan(0);
+    expect(res.body.couponCode).toBe('PROMO10');
+  });
+
+  it('404: deve rejeitar cupom inexistente', async () => {
+    const res = await request(app)
+      .post('/api/cart/coupon')
+      .set('Authorization', `Bearer ${customerToken}`)
+      .send({ code: 'NAOEXISTE' });
+
+    expect(res.status).toBe(404);
+  });
+
+  it('400: deve rejeitar cupom expirado', async () => {
+    const res = await request(app)
+      .post('/api/cart/coupon')
+      .set('Authorization', `Bearer ${customerToken}`)
+      .send({ code: 'EXPIRED' });
+
+    expect(res.status).toBe(400);
+  });
+});
+
+// ── GET /api/cart/shipping ────────────────────────────────────────────────────
+describe('GET /api/cart/shipping', () => {
+  it('200: deve retornar opções de frete calculadas para um CEP', async () => {
+    const res = await request(app)
+      .get('/api/cart/shipping?cep=01310100')
+      .set('Authorization', `Bearer ${customerToken}`);
+
+    expect(res.status).toBe(200);
+    expect(Array.isArray(res.body)).toBe(true);
+    expect(res.body.length).toBeGreaterThan(0);
+    expect(res.body[0]).toHaveProperty('name');
+    expect(res.body[0]).toHaveProperty('price');
+    expect(res.body[0]).toHaveProperty('estimatedDays');
+  });
+
+  it('400: deve rejeitar CEP inválido', async () => {
+    const res = await request(app)
+      .get('/api/cart/shipping?cep=123')
+      .set('Authorization', `Bearer ${customerToken}`);
+
+    expect(res.status).toBe(400);
+  });
+});

package/templates/ecommerce/apps/api/src/modules/cart/__tests__/cart.service.unit.test.ts

@@ -0,0 +1,151 @@
+import { CartService } from '../cart.service';
+import { ICartRepository } from '../cart.repository';
+import { ICouponRepository } from '../coupon.repository';
+import { IShippingService, ShippingOption } from '../shipping.service';
+import { IProductRepository } from '../../catalog/product.repository';
+import { CartEntity } from '../cart.entity';
+import { CouponEntity } from '../coupon.entity';
+
+jest.mock('../cart.repository');
+jest.mock('../coupon.repository');
+jest.mock('../shipping.service');
+jest.mock('../../catalog/product.repository');
+
+function makeVariant(overrides: Record<string, unknown> = {}) {
+  return {
+    id: 'var-1',
+    sku: 'CAM-P',
+    size: 'P',
+    color: 'Branco',
+    stock: 10,
+    price: null,
+    productId: 'prod-1',
+    ...overrides,
+  };
+}
+
+function makeProduct(overrides: Record<string, unknown> = {}) {
+  return {
+    id: 'prod-1',
+    name: 'Camiseta Básica',
+    slug: 'camiseta-basica',
+    price: 99.9,
+    images: [],
+    variants: [makeVariant()],
+    toRecord: jest.fn().mockReturnThis(),
+    ...overrides,
+  };
+}
+
+describe('CartService — Unit', () => {
+  let cartRepo: jest.Mocked<ICartRepository>;
+  let couponRepo: jest.Mocked<ICouponRepository>;
+  let shippingService: jest.Mocked<IShippingService>;
+  let productRepo: jest.Mocked<IProductRepository>;
+  let service: CartService;
+
+  beforeEach(() => {
+    cartRepo = {
+      findByUserId: jest.fn(),
+      findBySessionId: jest.fn(),
+      save: jest.fn(),
+      delete: jest.fn(),
+    } as jest.Mocked<ICartRepository>;
+
+    couponRepo = {
+      findByCode: jest.fn(),
+      findById: jest.fn(),
+      findAll: jest.fn(),
+      save: jest.fn(),
+      deleteById: jest.fn(),
+      incrementUsage: jest.fn(),
+    } as jest.Mocked<ICouponRepository>;
+
+    shippingService = {
+      calculate: jest.fn(),
+    } as jest.Mocked<IShippingService>;
+
+    productRepo = {
+      findById: jest.fn(),
+      findBySlug: jest.fn(),
+      findAll: jest.fn(),
+      search: jest.fn(),
+      create: jest.fn(),
+      update: jest.fn(),
+      softDelete: jest.fn(),
+      updateVariantStock: jest.fn(),
+      slugExists: jest.fn(),
+    } as jest.Mocked<IProductRepository>;
+
+    service = new CartService(cartRepo, couponRepo, shippingService, productRepo);
+  });
+
+  it('deve criar carrinho vazio para novo usuário', async () => {
+    cartRepo.findByUserId.mockResolvedValue(null);
+    cartRepo.save.mockImplementation(async (cart) => cart);
+
+    const cart = await service.getCart({ userId: 'user-1' });
+
+    expect(cart.items).toHaveLength(0);
+    expect(cart.userId).toBe('user-1');
+  });
+
+  it('deve persistir carrinho no "Redis" com TTL via save', async () => {
+    cartRepo.findByUserId.mockResolvedValue(null);
+    const savedCart = CartEntity.create('user-1');
+    cartRepo.save.mockResolvedValue(savedCart);
+
+    const item = { variantId: 'var-1', productId: 'prod-1', qty: 1 };
+    const product = makeProduct();
+    productRepo.findById.mockResolvedValue(product as never);
+    cartRepo.findByUserId.mockResolvedValueOnce(CartEntity.create('user-1'));
+    cartRepo.save.mockImplementation(async (c) => c);
+
+    await service.addItem({ userId: 'user-1' }, item);
+
+    expect(cartRepo.save).toHaveBeenCalled();
+  });
+
+  it('deve mesclar carrinho anônimo com carrinho do usuário ao login', async () => {
+    const anonCart = CartEntity.create(null, 'session-abc')
+      .addItem({ variantId: 'var-1', productId: 'prod-1', name: 'Camiseta', sku: 'CAM-P', price: 99.9, qty: 2, image: null });
+
+    const userCart = CartEntity.create('user-1')
+      .addItem({ variantId: 'var-2', productId: 'prod-2', name: 'Calça', sku: 'CAL-M', price: 150, qty: 1, image: null });
+
+    cartRepo.findBySessionId.mockResolvedValue(anonCart);
+    cartRepo.findByUserId.mockResolvedValue(userCart);
+    cartRepo.save.mockImplementation(async (c) => c);
+    cartRepo.delete.mockResolvedValue();
+
+    const merged = await service.mergeAnonymousCart('user-1', 'session-abc');
+
+    expect(merged.items).toHaveLength(2);
+    expect(cartRepo.delete).toHaveBeenCalledWith({ sessionId: 'session-abc' });
+  });
+
+  it('deve validar estoque disponível ao adicionar item', async () => {
+    const product = makeProduct({ variants: [makeVariant({ stock: 0 })] });
+    productRepo.findById.mockResolvedValue(product as never);
+    cartRepo.findByUserId.mockResolvedValue(CartEntity.create('user-1'));
+
+    await expect(
+      service.addItem({ userId: 'user-1' }, { variantId: 'var-1', productId: 'prod-1', qty: 1 }),
+    ).rejects.toThrow('Estoque insuficiente');
+  });
+
+  it('deve calcular opções de frete via shippingService', async () => {
+    const options: ShippingOption[] = [
+      { name: 'PAC', price: 18.5, estimatedDays: 7 },
+      { name: 'SEDEX', price: 32, estimatedDays: 2 },
+    ];
+    shippingService.calculate.mockResolvedValue(options);
+    cartRepo.findByUserId.mockResolvedValue(CartEntity.create('user-1'));
+
+    const result = await service.getShippingOptions({ userId: 'user-1' }, '01310-100');
+
+    expect(result).toHaveLength(2);
+    expect(result[0]!.name).toBe('PAC');
+    expect(shippingService.calculate).toHaveBeenCalledWith('01310-100', expect.any(Array));
+  });
+});

package/templates/ecommerce/apps/api/src/modules/cart/__tests__/coupon.admin.integration.test.ts

@@ -0,0 +1,136 @@
+/**
+ * Admin Coupon Routes — Integration Tests (Phase 13)
+ * Uses in-memory repositories; runs against the full Express app.
+ */
+import request from 'supertest';
+import app from '../../../app';
+import { userRepository } from '../../auth/auth.registry';
+import { UserEntity } from '../../auth/user.entity';
+import bcrypt from 'bcryptjs';
+
+let adminToken: string;
+let customerToken: string;
+
+beforeAll(async () => {
+  const adminHash = await bcrypt.hash('admin13pass', 1);
+  const admin = UserEntity.create({
+    name: 'Admin13',
+    email: 'admin13@test.com',
+    passwordHash: adminHash,
+    role: 'ADMIN',
+  });
+  await userRepository.create(admin);
+
+  const adminRes = await request(app)
+    .post('/api/auth/login')
+    .send({ email: 'admin13@test.com', password: 'admin13pass' });
+  adminToken = adminRes.body.accessToken as string;
+
+  const custHash = await bcrypt.hash('cust13pass', 1);
+  const customer = UserEntity.create({
+    name: 'Customer13',
+    email: 'customer13@test.com',
+    passwordHash: custHash,
+    role: 'CUSTOMER',
+  });
+  await userRepository.create(customer);
+
+  const custRes = await request(app)
+    .post('/api/auth/login')
+    .send({ email: 'customer13@test.com', password: 'cust13pass' });
+  customerToken = custRes.body.accessToken as string;
+});
+
+describe('Admin Coupon Routes', () => {
+  const validPayload = {
+    code: 'PHASE13TEST',
+    discountType: 'percent',
+    discountValue: 15,
+    minOrderValue: 0,
+    usageLimit: 100,
+    expiresAt: null,
+  };
+
+  it('POST /api/admin/coupons — 201: cria cupom com dados válidos', async () => {
+    const res = await request(app)
+      .post('/api/admin/coupons')
+      .set('Authorization', `Bearer ${adminToken}`)
+      .send(validPayload);
+
+    expect(res.status).toBe(201);
+    expect(res.body).toMatchObject({
+      id: expect.any(String),
+      code: 'PHASE13TEST',
+      discountType: 'percent',
+      discountValue: 15,
+      usageCount: 0,
+    });
+  });
+
+  it('POST /api/admin/coupons — 409: rejeita código duplicado', async () => {
+    // First creation
+    await request(app)
+      .post('/api/admin/coupons')
+      .set('Authorization', `Bearer ${adminToken}`)
+      .send({ ...validPayload, code: 'DUPLICATE13' });
+
+    // Second creation with same code
+    const res = await request(app)
+      .post('/api/admin/coupons')
+      .set('Authorization', `Bearer ${adminToken}`)
+      .send({ ...validPayload, code: 'DUPLICATE13' });
+
+    expect(res.status).toBe(409);
+  });
+
+  it('POST /api/admin/coupons — 400: rejeita payload inválido (discountValue <= 0)', async () => {
+    const res = await request(app)
+      .post('/api/admin/coupons')
+      .set('Authorization', `Bearer ${adminToken}`)
+      .send({ ...validPayload, code: 'BADVALUE13', discountValue: 0 });
+
+    expect(res.status).toBe(400);
+  });
+
+  it('POST /api/admin/coupons — 403: rejeita CUSTOMER', async () => {
+    const res = await request(app)
+      .post('/api/admin/coupons')
+      .set('Authorization', `Bearer ${customerToken}`)
+      .send(validPayload);
+
+    expect(res.status).toBe(403);
+  });
+
+  it('GET /api/admin/coupons — 200: retorna lista de cupons', async () => {
+    const res = await request(app)
+      .get('/api/admin/coupons')
+      .set('Authorization', `Bearer ${adminToken}`);
+
+    expect(res.status).toBe(200);
+    expect(res.body).toHaveProperty('items');
+    expect(Array.isArray(res.body.items)).toBe(true);
+  });
+
+  it('DELETE /api/admin/coupons/:id — 204: remove cupom', async () => {
+    const createRes = await request(app)
+      .post('/api/admin/coupons')
+      .set('Authorization', `Bearer ${adminToken}`)
+      .send({ ...validPayload, code: 'DELETEME13' });
+
+    const { id } = createRes.body as { id: string };
+
+    const res = await request(app)
+      .delete(`/api/admin/coupons/${id}`)
+      .set('Authorization', `Bearer ${adminToken}`);
+
+    expect(res.status).toBe(204);
+  });
+
+  it('DELETE /api/admin/coupons/:id — 400: id não-UUID', async () => {
+    const res = await request(app)
+      .delete('/api/admin/coupons/not-a-uuid')
+      .set('Authorization', `Bearer ${adminToken}`);
+
+    expect(res.status).toBe(400);
+  });
+});

package/templates/ecommerce/apps/api/src/modules/cart/cart.controller.ts

@@ -0,0 +1,94 @@
+import { Request, Response, NextFunction } from 'express';
+import { z } from 'zod';
+import { cartService } from './cart.registry';
+import type { CartKey } from './cart.service';
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+function cartKey(req: Request): CartKey {
+  // req.user is attached by authenticate middleware — always present on cart routes
+  const user = req.user as { id: string } | undefined;
+  if (user) return { userId: user.id };
+  // Fallback for anonymous access (not currently used — routes all require auth)
+  const sessionId = (req.headers['x-session-id'] as string | undefined) ?? 'anon';
+  return { sessionId };
+}
+
+// ── Zod schemas ───────────────────────────────────────────────────────────────
+const addItemSchema = z.object({
+  productId: z.string().min(1),
+  variantId: z.string().min(1),
+  qty: z.number().int().min(1, 'Quantidade deve ser maior que zero'),
+});
+
+const updateItemSchema = z.object({
+  qty: z.number().int().min(0, 'Quantidade não pode ser negativa'),
+});
+
+const applyCouponSchema = z.object({
+  code: z.string().min(1),
+});
+
+const shippingQuerySchema = z.object({
+  cep: z.string().regex(/^\d{8}$/, 'CEP inválido — use 8 dígitos numéricos'),
+});
+
+// ── Controllers ───────────────────────────────────────────────────────────────
+export async function getCart(req: Request, res: Response, next: NextFunction): Promise<void> {
+  try {
+    const cart = await cartService.getCart(cartKey(req));
+    res.status(200).json(cart.toRecord());
+  } catch (err) {
+    next(err);
+  }
+}
+
+export async function addItem(req: Request, res: Response, next: NextFunction): Promise<void> {
+  try {
+    const dto = addItemSchema.parse(req.body);
+    const cart = await cartService.addItem(cartKey(req), dto);
+    res.status(201).json(cart.toRecord());
+  } catch (err) {
+    next(err);
+  }
+}
+
+export async function updateItem(req: Request, res: Response, next: NextFunction): Promise<void> {
+  try {
+    const { variantId } = req.params as { variantId: string };
+    const { qty } = updateItemSchema.parse(req.body);
+    const cart = await cartService.updateItem(cartKey(req), variantId, qty);
+    res.status(200).json(cart.toRecord());
+  } catch (err) {
+    next(err);
+  }
+}
+
+export async function removeItem(req: Request, res: Response, next: NextFunction): Promise<void> {
+  try {
+    const { variantId } = req.params as { variantId: string };
+    await cartService.removeItem(cartKey(req), variantId);
+    res.status(204).send();
+  } catch (err) {
+    next(err);
+  }
+}
+
+export async function applyCoupon(req: Request, res: Response, next: NextFunction): Promise<void> {
+  try {
+    const { code } = applyCouponSchema.parse(req.body);
+    const cart = await cartService.applyCoupon(cartKey(req), code);
+    res.status(200).json(cart.toRecord());
+  } catch (err) {
+    next(err);
+  }
+}
+
+export async function getShipping(req: Request, res: Response, next: NextFunction): Promise<void> {
+  try {
+    const { cep } = shippingQuerySchema.parse(req.query);
+    const options = await cartService.getShippingOptions(cartKey(req), cep);
+    res.status(200).json(options);
+  } catch (err) {
+    next(err);
+  }
+}

package/templates/ecommerce/apps/api/src/modules/cart/cart.entity.ts

@@ -0,0 +1 @@
+export * from '../../domain/cart/cart.entity';

package/templates/ecommerce/apps/api/src/modules/cart/cart.registry.ts

@@ -0,0 +1 @@
+export * from '../../infrastructure/config/registry/cart.registry';

package/templates/ecommerce/apps/api/src/modules/cart/cart.repository.ts

@@ -0,0 +1,2 @@
+export * from '../../domain/cart/cart.repository';
+export * from '../../infrastructure/persistence/in-memory/cart.memory.repository';

package/templates/ecommerce/apps/api/src/modules/cart/cart.routes.ts

@@ -0,0 +1,17 @@
+import { Router } from 'express';
+import { authenticate } from '../../shared/middlewares/authenticate';
+import * as cartController from './cart.controller';
+
+const router = Router();
+
+// All cart routes require authentication (users must be logged in)
+router.use(authenticate);
+
+router.get('/', cartController.getCart);
+router.post('/items', cartController.addItem);
+router.patch('/items/:variantId', cartController.updateItem);
+router.delete('/items/:variantId', cartController.removeItem);
+router.post('/coupon', cartController.applyCoupon);
+router.get('/shipping', cartController.getShipping);
+
+export default router;

package/templates/ecommerce/apps/api/src/modules/cart/cart.service.ts

@@ -0,0 +1 @@
+export * from '../../application/cart/cart.service';

package/templates/ecommerce/apps/api/src/modules/cart/coupon.entity.ts

@@ -0,0 +1 @@
+export * from '../../domain/cart/coupon.entity';

package/templates/ecommerce/apps/api/src/modules/cart/coupon.repository.ts

@@ -0,0 +1,2 @@
+export * from '../../domain/cart/coupon.repository';
+export * from '../../infrastructure/persistence/in-memory/coupon.memory.repository';

package/templates/ecommerce/apps/api/src/modules/cart/coupon.service.ts

@@ -0,0 +1 @@
+export * from '../../application/cart/coupon.service';

package/templates/ecommerce/apps/api/src/modules/cart/shipping.service.ts

@@ -0,0 +1,2 @@
+export * from '../../application/ports/shipping.port';
+export * from '../../infrastructure/services/shipping/mock.shipping.service';