go-ddd

Practical DDD(Domain Driven Design) & CQRS implementation on order bounded context

Prerequisites

go 1.22.1

Warming - Up

• run in terminal: make run
• Locate to http://localhost:8080/swagger/index.html

Helm

• make helm-charts

Futures

• Health checks
• Graceful shutdown on interrupt signals
• Global http error handling with Problem Details rfc7807
• Prometheus metrics for echo
• Swagger docs (/swagger/index.html)
• Graceful config management by viper
• Mediator usage for command dispatching & dynamic behaviours
• DDD structure
• Optimistic concurrency control.
• Docker, K8s, Helm.
• Distroless docker image usage
• OTEL(open telemetry) & grafana/otel-lgtm integration
• Structured Logging with slog
• (TODO): Toxiproxy for resilency testing
• (TODO): Tilt & kind setup

Libraries

• mediator https://github.com/eyazici90/go-mediator
• echo https://github.com/labstack/echo
• viper https://github.com/spf13/viper
• validator https://github.com/go-playground/validator
• swaggo https://github.com/swaggo/echo-swagger
• retry-go https://github.com/avast/retry-go
• testify https://github.com/stretchr/testify
• golangci https://github.com/golangci/golangci-lint

Note:

Check vertical-slice branch for Vertical-Slice (feature driven) packaging style structure.

Command dispatcher

Mediator with pipeline behaviours (order matters for pipeline behaviours)

     sender, err := mediator.New(
		// Behaviors
		mediator.WithBehaviourFunc(behavior.Measure),
		mediator.WithBehaviourFunc(behavior.Validate),
		mediator.WithBehaviour(behavior.NewCancellator(timeout)),
		// Handlers
		mediator.WithHandler(command.CreateOrder{}, command.NewCreateOrderHandler(store)),
		mediator.WithHandler(command.PayOrder{}, command.NewPayOrderHandler(store, store)),
		mediator.WithHandler(command.ShipOrder{}, command.NewShipOrderHandler(store, store, ep)),
	)


    err = sender.Send(ctx, cmd)

Command & Command handler

    type  CreateOrderCommand  struct {
        Id string  `validate:"required,min=10"`
    }

    type  CreateOrderCommandHandler  struct {
        orderCreator OrderCreator
    }

    func (CreateOrderCommand) Key() int { return createCommandKey }

    func  NewCreateOrderCommandHandler(orderCreator OrderCreator) CreateOrderCommandHandler {
        return CreateOrderHandler{orderCreator: orderCreator}
    }

    func (h CreateOrderCommandHandler) Handle(ctx context.Context, msg mediator.Message) error {
       cmd, ok := msg.(CreateOrder)
	if err := checkType(ok); err != nil {
		return err
	}

	ordr, err := order.NewOrder(order.ID(cmd.ID), order.NewCustomerID(), order.NewProductID(), time.Now,
		order.Submitted, aggregate.NewVersion())

	if err != nil {
		return errors.Wrap(err, "create order handle failed")
	}

	return h.orderCreator.Create(ctx, ordr)
    }

Pipeline Behaviours

Auto command validation

    var  validate *validator.Validate = validator.New()

    type  Validator  struct{}

    func  NewValidator() *Validator { return &Validator{} }

    func (v *Validator) Process(ctx context.Context, msg mediator.Message, next mediator.Next) error {

        if  err := validate.Struct(msg); err != nil {
    	    return err
        }

        return  next(ctx)
    }

Context timeout

    type  Cancellator  struct {
        timeout int
    }

    func  NewCancellator(timeout int) *Cancellator { return &Cancellator{timeout} }

    func (c *Cancellator) Process(ctx context.Context, msg mediator.Message, next mediator.Next) error {

        timeoutContext, cancel := context.WithTimeout(ctx, time.Duration(time.Duration(c.timeout)*time.Second))

        defer  cancel()

        result := next(timeoutContext)

        return result

    }

IAC

TBD