feat: Implement order service (cart + checkout)

[rezadrian01]

Summary

• Implement complete order service (port 8083) with cart management and order checkout flow
• Fix Docker Compose DATABASE_URL ports for all services (host port → container port 5432)
• Add PRODUCT_SERVICE_URL env var to order-service; provision Kafka topics for order events

What's included

Domain layer (internal/domain/)

• Cart, CartItem, Order, OrderItem entities with GORM tags and ToResponse() helpers
• OrderStatus type with Cancellable() helper (blocks cancel on shipped/delivered)
• Full set of interfaces: CartRepository, OrderRepository, CartService, OrderService, CartCache, OrderCache, EventPublisher, ProductClient
• ProductSnapshot struct — price and name are snapshotted at cart-add time so historical orders are unaffected by product edits

DB migrations (db/)

• 001_create_carts.up.sql — carts (UNIQUE on user_id) + cart_items with CHECK constraint on quantity
• 002_create_orders.up.sql — orders with CHECK constraint on status enum + order_items

Repository layer (internal/repository/)

• CartRepository — full CRUD for carts and items; ClearCart deletes all items by cart_id
• OrderRepository — CreateOrder uses an explicit transaction (inserts order then sets FK on each item); UpdateOrderStatus does a targeted column update then re-fetches

Cache layer (internal/cache/)

• CartCache — key cart:<userID>, 24 h TTL
• OrderCache — order detail order:<id> (1 h TTL), order list orders:user:<uid>:page:<n>:limit:<l> (5 min TTL); InvalidateOrderList scans by user prefix

Events (internal/events/)

• Kafka publisher for order.created, order.updated, order.cancelled; all publishes are fire-and-forget goroutines so Kafka unavailability never blocks HTTP responses

Product HTTP client (internal/client/)

• Calls GET {PRODUCT_SERVICE_URL}/products/{id} with 5 s timeout
• Returns ErrProductInactive immediately if is_active == false — prevents snapshotting a dead product into the cart

Service layer (internal/service/)

• CartService — auto-creates cart on first access; AddItem merges quantity if product already in cart and refreshes price snapshot; UpdateItem/RemoveItem verify item ownership (item.CartID == cart.ID) before touching anything
• OrderService — CreateOrder builds order items from cart snapshots in one transaction, clears cart after checkout; CancelOrder checks Status.Cancellable() before proceeding

Handler + Route layers (internal/handler/, internal/route/)

• 8 endpoints matching gateway routes exactly (4 cart, 4 order)
• User identity read from X-User-ID header injected by the gateway proxy
• Typed error mapping to HTTP status codes

Bootstrap (cmd/, main.go, Dockerfile)

• Same pattern as product-service: config, dotenv loader, GORM AutoMigrate, Redis ping-on-startup, Kafka writer setup with ensureTopics, full dependency wiring, graceful shutdown

docker-compose fix

• products-db, orders-db, payments-db, inventory-service were all using the host-mapped port in their DATABASE_URL — inside Docker containers communicate on the container port (5432), not the host port. Fixed across all four affected services.

Test plan

• go build ./... passes in services/order-service/
• go vet ./... passes with zero warnings
• docker compose up orders-db redis kafka order-service starts and /health returns 200
• POST /api/cart/items with a valid product UUID adds item and returns cart with correct price snapshot
• POST /api/orders with shipping details creates order, clears cart, returns pending status
• PUT /api/orders/:id/cancel on a pending order returns cancelled; on a shipped order returns 409
• Kafka topic order.created receives a message after checkout

🤖 Generated with Claude Code