┌─────────────────────────────────────────────────────────────┐
│                   Temporal Server                          │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐      │
│  │  Frontend    │  │   History    │  │   Matching   │      │
│  │   (gRPC)     │  │   (Events)   │  │   (Tasks)    │      │
│  └──────────────┘  └──────────────┘  └──────────────┘      │
│                                                             │
│  Persistence: PostgreSQL / MySQL / Cassandra / Elasticsearch│
└─────────────────────────────────────────────────────────────┘
           │
           │ gRPC
           ▼
┌─────────────────────────────────────────────────────────────┐
│                   Workers (Go)                             │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐      │
│  │   Workflow   │  │   Activity   │  │   Activity   │      │
│  │   Engine     │  │   Executor   │  │   Executor   │      │
│  └──────────────┘  └──────────────┘  └──────────────┘      │
│                                                             │
│  Workflows são determinísticos (replayable)                │
│  Activities contêm side-effects (I/O, APIs)                │
└─────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│  MICROSERVIÇO          │  GO                                    │
├─────────────────────────────────────────────────────────────────┤
│  Leve e rápido         │  Binário único, startup < 100ms        │
├─────────────────────────────────────────────────────────────────┤
│  Escalável             │  Goroutines (milhões simultâneas)      │
├─────────────────────────────────────────────────────────────────┤
│  Confiável             │  Tipagem forte, sem runtime pesado     │
├─────────────────────────────────────────────────────────────────┤
│  Eficiente             │  Memória mínima (10-50MB por serviço)  │
├─────────────────────────────────────────────────────────────────┤
│  Portátil              │  Cross-compile, Docker nativo          │
├─────────────────────────────────────────────────────────────────┤
│  Simples               │  Código explícito, fácil manutenção    │
└─────────────────────────────────────────────────────────────────┘

order-service/
├── cmd/
│   └── api/
│       └── main.go              # Entry point
├── internal/
│   ├── domain/
│   │   ├── order.go             # Entidades
│   │   └── errors.go            # Erros de domínio
│   ├── application/
│   │   ├── service.go           # Lógica de negócio
│   │   └── dto.go               # Data Transfer Objects
│   ├── infrastructure/
│   │   ├── http/
│   │   │   ├── handler.go       # HTTP handlers
│   │   │   ├── router.go        # Configuração de rotas
│   │   │   └── middleware.go    # Middlewares
│   │   ├── persistence/
│   │   │   ├── postgres.go      # Implementação do repo
│   │   │   └── redis.go         # Cache
│   │   └── messaging/
│   │       └── kafka.go         # Event publisher
│   └── config/
│       └── config.go            # Configurações
├── pkg/
│   └── logger/                  # Shared packages
├── api/
│   └── proto/                   # Protocol Buffers
├── deployments/
│   ├── docker/
│   └── k8s/
├── go.mod
└── Makefile

// internal/domain/order.go
package domain

import (
	"errors"
	"time"
)

var (
	ErrInvalidAmount  = errors.New("valor do pedido inválido")
	ErrOrderNotFound  = errors.New("pedido não encontrado")
)

type Order struct {
	ID        string    `json:"id"`
	UserID    string    `json:"user_id"`
	Items     []Item    `json:"items"`
	Total     float64   `json:"total"`
	Status    Status    `json:"status"`
	CreatedAt time.Time `json:"created_at"`
}

type Item struct {
	ProductID string  `json:"product_id"`
	Quantity  int     `json:"quantity"`
	Price     float64 `json:"price"`
}

type Status string

const (
	StatusPending   Status = "PENDING"
	StatusPaid      Status = "PAID"
	StatusShipped   Status = "SHIPPED"
	StatusDelivered Status = "DELIVERED"
)

func (o *Order) CalculateTotal() {
	var total float64
	for _, item := range o.Items {
		total += item.Price * float64(item.Quantity)
	}
	o.Total = total
}

func (o *Order) Validate() error {
	if o.Total <= 0 {
		return ErrInvalidAmount
	}
	return nil
}

// internal/application/service.go
package application

import (
	"context"
	"fmt"
	"time"

	"order-service/internal/domain"
)

// Portas (interfaces) para dependências
type OrderRepository interface {
	Save(ctx context.Context, order *domain.Order) error
	GetByID(ctx context.Context, id string) (*domain.Order, error)
	Update(ctx context.Context, order *domain.Order) error
}

type PaymentService interface {
	Process(ctx context.Context, orderID string, amount float64) error
}

type EventPublisher interface {
	PublishOrderCreated(ctx context.Context, order *domain.Order) error
}

type OrderService struct {
	repo      OrderRepository
	payment   PaymentService
	publisher EventPublisher
}

func NewOrderService(
	repo OrderRepository,
	payment PaymentService,
	publisher EventPublisher,
) *OrderService {
	return &OrderService{
		repo:      repo,
		payment:   payment,
		publisher: publisher,
	}
}

func (s *OrderService) CreateOrder(ctx context.Context, userID string, items []domain.Item) (*domain.Order, error) {
	order := &domain.Order{
		ID:        generateID(),
		UserID:    userID,
		Items:     items,
		Status:    domain.StatusPending,
		CreatedAt: time.Now(),
	}

	order.CalculateTotal()
	if err := order.Validate(); err != nil {
		return nil, err
	}

	// Salvar no banco
	if err := s.repo.Save(ctx, order); err != nil {
		return nil, fmt.Errorf("falha ao salvar pedido: %w", err)
	}

	// Publicar evento assíncrono
	go func() {
		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
		defer cancel()
		s.publisher.PublishOrderCreated(ctx, order)
	}()

	return order, nil
}

func (s *OrderService) ProcessPayment(ctx context.Context, orderID string) error {
	order, err := s.repo.GetByID(ctx, orderID)
	if err != nil {
		return err
	}

	if err := s.payment.Process(ctx, orderID, order.Total); err != nil {
		return fmt.Errorf("pagamento falhou: %w", err)
	}

	order.Status = domain.StatusPaid
	return s.repo.Update(ctx, order)
}

func generateID() string {
	return fmt.Sprintf("ORD-%d", time.Now().UnixNano())
}