Stage 10 - The Handshake

package application

import (
	"minimart/order/domain"
	"minimart/pkg/module/contracts"
)

// Service is the order application layer. It depends on the order repository port
// and on other domains through the contracts.Modules INTERFACE - never on their
// concrete packages. Depending on the interface is what lets tests pass a fake.
type Service struct {
	repo    domain.Repository
	modules contracts.Modules
}

func NewService(repo domain.Repository, modules contracts.Modules) *Service {
	return &Service{repo: repo, modules: modules}
}

go build ./order/application/...

package application

import (
	"context"
	"fmt"

	"minimart/order/domain"
)

// PlaceOrderRequest is the input to PlaceOrder. It carries NO prices or names:
// those are authoritative from the catalog, fetched below. The client only says
// which product and how many.
type PlaceOrderRequest struct {
	UserID string
	Items  []PlaceOrderItem
}

type PlaceOrderItem struct {
	ProductID string
	Quantity  int
}

// PlaceOrder resolves each product's real price from the catalog (through the
// published contract), builds the order, and saves it. The order domain trusts
// the catalog for prices, not the caller.
func (s *Service) PlaceOrder(ctx context.Context, req PlaceOrderRequest) (domain.Order, error) {
	if len(req.Items) == 0 {
		return domain.Order{}, domain.ErrNoItems
	}
	items := make([]domain.Item, 0, len(req.Items))
	for _, it := range req.Items {
		if it.Quantity <= 0 {
			return domain.Order{}, domain.ErrInvalidQuantity
		}
		p, err := s.modules.GetProduct(ctx, it.ProductID)
		if err != nil {
			return domain.Order{}, fmt.Errorf("resolve product %s: %w", it.ProductID, err)
		}
		items = append(items, domain.Item{
			ProductID:      p.ID,
			Name:           p.Name,
			UnitPriceCents: p.PriceCents,
			Quantity:       it.Quantity,
		})
	}
	order, err := domain.NewOrder(newID(), req.UserID, items)
	if err != nil {
		return domain.Order{}, err
	}
	if err := s.repo.Save(ctx, order); err != nil {
		return domain.Order{}, err
	}
	return order, nil
}

// placeOrderRequest is the body of POST /v1/orders. Note there is no price field:
// the client cannot set prices. It only names products and quantities.
type placeOrderRequest struct {
	UserID string           `json:"user_id"`
	Items  []placeOrderItem `json:"items"`
}

type placeOrderItem struct {
	ProductID string `json:"product_id"`
	Quantity  int    `json:"quantity"`
}

func (h *Handlers) PlaceOrder(w http.ResponseWriter, r *http.Request) {
	var req placeOrderRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		writeJSON(w, http.StatusBadRequest, errorResponse{"invalid JSON body"})
		return
	}
	items := make([]application.PlaceOrderItem, 0, len(req.Items))
	for _, it := range req.Items {
		items = append(items, application.PlaceOrderItem{ProductID: it.ProductID, Quantity: it.Quantity})
	}
	o, err := h.svc.PlaceOrder(r.Context(), application.PlaceOrderRequest{
		UserID: req.UserID,
		Items:  items,
	})
	if err != nil {
		respondDomainError(w, err)
		return
	}
	writeJSON(w, http.StatusCreated, toOrderResponse(o))
}

go build ./order/application/... ./order/presentation/http/...

package http

import (
	"encoding/json"
	"errors"
	"net/http"

	catalogclient "minimart/catalog/presentation/module/client"
	"minimart/order/domain"
)

func writeJSON(w http.ResponseWriter, status int, body any) {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(status)
	_ = json.NewEncoder(w).Encode(body)
}

type errorResponse struct {
	Error string `json:"error"`
}

// respondDomainError maps order-domain errors AND the catalog contract's
// ErrProductNotFound to HTTP status codes. A product the caller named that does
// not exist is a bad request (the caller's input was wrong), not a 404 on the
// order resource.
func respondDomainError(w http.ResponseWriter, err error) {
	switch {
	case errors.Is(err, domain.ErrOrderNotFound):
		writeJSON(w, http.StatusNotFound, errorResponse{err.Error()})
	case errors.Is(err, domain.ErrNoItems),
		errors.Is(err, domain.ErrInvalidQuantity),
		errors.Is(err, catalogclient.ErrProductNotFound):
		writeJSON(w, http.StatusBadRequest, errorResponse{err.Error()})
	default:
		writeJSON(w, http.StatusInternalServerError, errorResponse{"internal error"})
	}
}

package order

import (
	"context"
	"net/http"

	"minimart/order/application"
	"minimart/order/infrastructure/memory"
	orderhttp "minimart/order/presentation/http"
	"minimart/pkg/module"
	"minimart/pkg/module/contracts"
)

// Module wires the order domain. It holds the shared contracts registry so its
// service can call other domains through it.
type Module struct {
	registry *contracts.Contracts
	svc      *application.Service
	handlers *orderhttp.Handlers
}

var _ module.Module = (*Module)(nil)

// NewModule receives the shared registry pointer. Its slots are empty now and
// filled during RegisterContracts, before any request runs - so it is safe to
// stash here and call later from request handlers.
func NewModule(registry *contracts.Contracts) *Module {
	return &Module{registry: registry}
}

func (m *Module) Name() string { return "order" }

func (m *Module) Init(ctx context.Context) error {
	repo := memory.New()
	m.svc = application.NewService(repo, m.registry)
	m.handlers = orderhttp.NewHandlers(m.svc)
	return nil
}

// RegisterContracts is a no-op: the order domain publishes no contract of its own
// (nothing else calls into it) - it only consumes the catalog contract.
func (m *Module) RegisterContracts(ctx context.Context, c *contracts.Contracts) error {
	return nil
}

func (m *Module) RegisterHTTP(ctx context.Context, mux *http.ServeMux) error {
	m.handlers.Register(mux)
	return nil
}

	modules := []module.Module{
		catalog.NewModule(),
		order.NewModule(registry),
	}