Tactical DDD patterns in Go

roblaszczak
TACTICAL DDD
PATTERNS IN GOLANG

roblaszczak
Hello!
● Co-founder @Tree Dots Labs

roblaszczak
Hello!
● Co-founder @Tree Dots Labs
● Golang, Python, PHP

roblaszczak
10
Dlaczego to nie działa tak jak
ustaliliśmy?

roblaszczak
11
Myśleliśmy że wiecie że to tak
będzie działać

roblaszczak
12
Czy ktoś w ogóle wie jak to
działa?

roblaszczak
13
Poczekaj, sprawdzę w tym
handlerze na 1k linii i w
triggerach DB

roblaszczak
Nie do końca to mieliśmy na
myśli mówiąc “klient kupił
produkt”...
14

roblaszczak
19
DOKŁADNE
ODZWIERCIEDLENIE
LOGIKI BIZNESOWEJ

roblaszczak
20
KOD KTÓRY MOŻNA
POKAZAĆ EKSPERTOWI
DOMENOWEMU

roblaszczak
21
BEZPIECZNE
WPROWADZANIE
ZNACZĄCYCH ZMIAN W
LOGICE BIZNESOWEJ

roblaszczak
22
LEGENDARNY
SAMODOKUMENTUJĄCY
SIĘ KOD

roblaszczak
23
UPORZĄDKOWANIE
NAZEWNICTWA

roblaszczak
24
WERYFIKACJA LOGIKI
DOMENOWEJ PRZED
ROZPOCZĘCIEM
IMPLEMENTACJI

roblaszczak
29
Nurse administer standard flu
vaccine dose to adult patient.

roblaszczak
30
patient := patient.NewPatient()
patient.SetShotType(vaccine.Flu)
patient.SetDose(10)
patient.SetNurse(nurse)

roblaszczak
31
patient := patient.NewPatient()
patient.SetShotType(vaccine.Flu)
patient.SetDose(10)
patient.SetNurse(nurse)

roblaszczak
32
patient.GiveFluShot()

roblaszczak
33
patient.GiveFluShot()

roblaszczak
34
vaccine :=
vaccine.StandardAdultFluDose()
nurse.AdministerFluVaccine(
patient,
vaccine,
)

roblaszczak
35
Nurse administer standard flu
vaccine dose to adult patient.

roblaszczak
36
vaccine :=
vaccine.StandardAdultFluDose()
nurse.AdministerFluVaccine(
patient,
vaccine,
)

roblaszczak
39
package backlog
type ItemID struct{ id.ID }
type Item struct {
id ItemID
name string
// ...
}

roblaszczak
40
package backlog
type Item struct {
id ItemID
name string
// ...
}

roblaszczak
41

roblaszczak
42
package id
type ID struct {
u ulid.ULID
valid bool
}
func New() ID {
return ID{ulid.MustNew(ulid.Timestamp(time.Now()), rand.Reader), true}
}
func FromString(s string) (ID, error) {}
func (i ID) String() string {}
func (i ID) Bytes() []byte {}
func (i ID) Equals(toCompare ID) bool {}
func (i ID) Empty() bool {}

roblaszczak
43
type ItemID id.ID

roblaszczak
44
type ItemID id.ID

roblaszczak
45

roblaszczak
46
func NewItem(id ItemID, name string) (*Item, error) {
if id.Empty() {
return nil, ErrItemEmptyID
}
i := &Item{id: id}
if err := i.ChangeName(name); err != nil {
return nil, err
}
return i, nil
}

roblaszczak
47
func (i *Item) ChangeName(name string) error
{
if name == "" {
return ErrItemEmptyName
}
i.name = name
return nil
}

roblaszczak
48
var (
ErrItemEmptyName =
domain.NewIllegalStateError("name cannot be empty")
)

roblaszczak
49
func (i *Item) changeName(name string)
error {
if name == "" {
return ErrItemEmptyName
}
i.name = name
return nil
}

roblaszczak
50
func NewItem(id ItemID, name string) (*Item, error) {
if id.Empty() {
return nil, ErrItemEmptyID
}
i := &Item{id: id}
if err := i.ChangeName(name); err != nil {
return nil, err
}
return i, nil
}

roblaszczak
51
{
"valid_item",
args{backlog.ItemID{id.New()}, "foo"},
nil,
}, {
"missing_id",
args{backlog.ItemID{}, "foo"},
backlog.ErrItemEmptyID,
}, {
"missing_name",
args{backlog.ItemID{id.New()}, ""},
backlog.ErrItemEmptyName,

roblaszczak
52
{
"valid_item",
args{backlog.ItemID{id.New()}, "foo"},
nil,
}, {
"missing_id",
args{backlog.ItemID{}, "foo"},
backlog.ErrItemEmptyID,
}, {
"missing_name",
args{backlog.ItemID{id.New()}, ""},
backlog.ErrItemEmptyName,

roblaszczak
53
func TestNewItem(t *testing.T) {
type args struct {
id backlog.ItemID
name string
}
tests := []struct {
name string
args args
wantErr error
}{

roblaszczak
54
t.Run(tt.name, func(t *testing.T) {
_, err := backlog.NewItem(
tt.args.id, tt.args.name
)
assert.Equal(t, tt.wantErr, err)
})

roblaszczak
55
Lifetip: CTRL + Shift + T

roblaszczak
56
package backlog_test

roblaszczak
57
tests := []struct {
name string
args args
wantErr error
}{

roblaszczak
58
func TestItem_ChangeName(t *testing.T) {

roblaszczak
60
{
name: "scheduled_for_release",
item: createTestScheduledForReleaseItem(t),
wantErr: nil,
},

roblaszczak
62
{
name: "scheduled_for_release",
item: createTestScheduledForReleaseItem(t),
wantErr: nil,
},

roblaszczak
63
{
name: "not_scheduled_for_release",
item: createTestItem(t),
wantErr: backlog.ErrMustBeScheduledToCommit,
},

roblaszczak
64
{
name: "already_commited_to_sprint",
item: createTestCommitedToSprintItem(t),
wantErr: nil,
},

roblaszczak
65
func createTestItem(t *testing.T) *backlog.Item {
i, err := backlog.NewItem(
backlog.ItemID{id.New()},
"Foo",
)
require.NoError(t, err)
return i
}

roblaszczak
66
func createTestItem(t *testing.T) *backlog.Item {
i, err := backlog.NewItem(
backlog.ItemID{id.New()},
"Foo",
)
return i
}

roblaszczak
67
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"

roblaszczak
68
func createTestScheduledForReleaseItem(t *testing.T)
*backlog.Item {
i := createTestItem(t)
err := i.ScheduleRelease(time.Now())
return i
}

roblaszczak
69
func createTestCommitedToSprintItem(t *testing.T)
*backlog.Item {
i := createTestScheduledForReleaseItem(t)
s := createTestSprint(t)
err := i.CommitToSprint(s)
return i
}

roblaszczak
70
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
s := createTestSprint(t)
initialSprintID := tt.i.CommitedSprintID()
initialStatus := tt.i.Status()
err := tt.i.CommitToSprint(s)
assert.Equal(t, tt.wantErr, err)
// ...
})
}

roblaszczak
71
if tt.wantErr == nil {
assert.Equal(t, s.ID(), tt.i.CommitedSprintID())
assert.NotEqual(t, s.ID(), initialSprintID)
assert.Equal(
t, tt.i.Status(),
backlog.ItemStatusCommited
)
} else {
assert.Equal(t,initialSprintID,tt.i.CommitedSprintID())
assert.Equal(t, tt.item.Status(), initialStatus)
}

roblaszczak
72
assert.Equal(
t, tt.i.Status(),
)
} else {
}

roblaszczak
73
assert.Equal(
t, tt.i.Status(),
)
} else {
}

roblaszczak
74
assert.Equal(
t, tt.i.Status(),
)
} else {
}

roblaszczak
75
func (i *Item) CommitToSprint(s *sprint.Sprint) error {
if !i.IsScheduledForRelease() {
return ErrMustBeScheduledToCommit
}
if i.IsCommittedToSprint() {
i.UncommitFromSprint()
}
i.setStatus(ItemStatusCommited)
i.setSprintID(s.ID())
return nil
}

roblaszczak
76
}
}
return nil
}

roblaszczak
77
}
}
return nil
}

roblaszczak
78
}
}
return nil
}

roblaszczak
80
}
}
return nil
}

roblaszczak
82
(RACZEJ)
NIE POSIADA ID

roblaszczak
84
NIE POSIADA ZACHOWAŃ

roblaszczak
85
CZĘSTO ŁĄCZY 2
WARTOŚCI KTÓRE
ODDZIELNIE NIE MAJĄ
SENSU

roblaszczak
86
type Price struct {
cents int
currency string
}

roblaszczak
87
func NewPrice(cents int, currency string) (Price, error)
{
if cents <= 0 {
return Price{}, ErrCentsTooLow
}
if len(currency) != 3 {
return Price{}, ErrInvalidCurrency
}
return Price{cents, currency}, nil
}

roblaszczak
88
{
if cents <= 0 {
}
}
}

roblaszczak
89
{
if cents <= 0 {
}
}
}

roblaszczak
91
func (p Price) Empty() bool {
return p.cents == 0 || p.currency == ""
}

roblaszczak
92
func (p Price) Add(toAdd Price) (Price, error) {
if p.currency != toAdd.currency {
return Price{}, ErrCurrencyDoesntMatch
}
return NewPrice(p.cents+toAdd.cents, p.currency)
}

roblaszczak
96
ODKŁADAMY DECYZJĘ
O BAZIE DANYCH
NA PÓŹNIEJ

roblaszczak
97
package backlog
type ItemRepository interface {
Add(*Item) error
ByID(ItemID) (*Item, error)
Update(*Item) error
}

roblaszczak
98
package backlog
// ….
var (
ErrItemNotFound = errors.New("item not found")
ErrItemAlreadyExists = errors.New("item already
exists")
)

roblaszczak
99
package backlog
type ItemRepository interface {
Add(*Item) error
ByID(ItemID) (*Item, error)
Update(*Item) error
}

roblaszczak
100
type BacklogItemRepository struct {
items map[string]backlog.Item
}
func (r *BacklogItemRepository) Add(i *backlog.Item)
error {
if _, ok := r.items[i.ID().String()]; ok {
return backlog.ErrItemAlreadyExists
}
r.items[i.ID().String()] = *i
return nil
}

roblaszczak
101
}
error {
}
return nil
}

roblaszczak
102
}
error {
}
return nil
}

roblaszczak
103
Jak tego teraz użyć?

roblaszczak
105
MAŁE SERWISY
APLIKACYJNE
PER USE CASE

roblaszczak
108
type CommitBacklogItemToSprint struct {
BacklogItemID backlog.ItemID
SprintID sprint.ID
}

roblaszczak
109
SprintID sprint.ID
}

roblaszczak
110
type CommitBacklogItemToSprintHandler struct {
sprintRepository sprint.Repository
backlogItemRepository backlog.ItemRepository
}

roblaszczak
111
func NewCommitToSprintHandler(
sprintRepository sprint.Repository,
backlogItemRepository backlog.ItemRepository,
) CommitBacklogItemToSprintHandler {
return CommitBacklogItemToSprintHandler{
sprintRepository,
backlogItemRepository,
}
}

roblaszczak
112
func NewCommitToSprintHandler(
sprintRepository sprint.Repository,
backlogItemRepository backlog.ItemRepository,
) CommitBacklogItemToSprintHandler {
return CommitBacklogItemToSprintHandler{
sprintRepository,
backlogItemRepository,
}
}

roblaszczak
113
}

roblaszczak
114
}

roblaszczak
115
type AddBacklogItem struct {
ID backlog.ItemID
Name string
}
func (a AddBacklogItemHandler) Handle(cmd AddBacklogItem)
error {
i, err := backlog.NewItem(cmd.ID, cmd.Name)
if err != nil {
return err
}
return a.backlogItemRepository.Add(i)
}

roblaszczak
116
ID backlog.ItemID
Name string
}
error {
if err != nil {
return err
}
}

roblaszczak
117
ID backlog.ItemID
Name string
}
error {
if err != nil {
return err
}
}

roblaszczak
118
ID backlog.ItemID
Name string
}
error {
if err != nil {
return err
}
}

roblaszczak
119
type AddSprint struct {
// ...

roblaszczak
120
SprintID sprint.ID
}

roblaszczak
121
func (c CommitBacklogItemToSprintHandler) Handle(cmd
CommitBacklogItemToSprint) error {
sprint, err := c.sprintRepository.ByID(cmd.SprintID)
if err != nil {
return err
}
item, err :=
c.backlogItemRepository.ByID(cmd.BacklogItemID)
if err != nil {
return err
}
// ...

roblaszczak
122
sprint, err := c.sprintRepository.ByID(cmd.SprintID)
if err != nil {
return err
}
item, err :=
c.backlogItemRepository.ByID(cmd.BacklogItemID)
if err != nil {
return err
}
// ...

roblaszczak
123
// ...
if err := item.CommitToSprint(sprint); err != nil {
return err
}
return c.backlogItemRepository.Update(item)
}

roblaszczak
124
// …
if item.IsCommitedToBacklog() {
return err
}
// …
}

roblaszczak
125
// …
if item.IsCommitedToBacklog() {
return err
}
// …
}

roblaszczak
126
DOBRE MIEJSCE NA
CROSS-CUTTING
CONCERNS

roblaszczak
128
r.Get("/sprint/{sprintID}/backlog/item/{itemID}", func(w
http.ResponseWriter, r *http.Request) {
backlogItemID := id.FromStringMust(chi.URLParam(r, "itemID"))
sprintID := id.FromStringMust(chi.URLParam(r, "sprintID"))
err := h.Handle(command.CommitBacklogItemToSprint{
BacklogItemID: backlog.ItemID{backlogItemID},
SprintID: sprint.ID{sprintID},
})
if err != nil {
log.Println("error:", err.Error())
w.WriteHeader(http.StatusInternalServerError)
return
}

roblaszczak
129
})
if err != nil {
return
}

roblaszczak
130
})
if err != nil {
return
}

roblaszczak
131
Gdzie to
teraz
upchnąć?

roblaszczak
132
Jeden package
==
tracimy
enkapsulację

roblaszczak
133
.
├── app
│ └── command
├── domain
│ ├── backlog
│ └── sprint
├── infrastructure
│ └── memory
└── interfaces
└── rest

roblaszczak
134
.
├── app
├── domain
└── rest

roblaszczak
135
.
├── app
├── domain
└── rest

roblaszczak
136
.
├── app
├── domain
└── rest

roblaszczak
137
.
├── app
├── domain
└── rest

roblaszczak
138
domain
├── backlog
│ ├── item.go
│ ├── item_status.go
│ ├── repository.go
│ └── unmarshal.go
├── error.go
└── sprint
├── repository.go
└── sprint.go

roblaszczak
140
github.com/roblaszczak/go-cleanarch

roblaszczak
141
github.com/roblaszczak/go-cleanarch
(wszystkie linki podam pod koniec prezentacji)

roblaszczak
144
type Item struct {
id ItemID `json:"id"`
name string `json:"name"`
status ItemStatus `json:"status"`
releaseSchedule time.Time `json:"release_schedule"`
commitedSprintID sprint.ID `json:"commited_sprint_id"`
}

roblaszczak
145
Zmiana widoku
wymaga zmiany w
domenie

roblaszczak
146
Atrybuty są
prywatne więc się
nie zmarshalują :)

roblaszczak
147
type BacklogItemView struct {
ID string `json:"id"`
Name string `json:"name"`
}
func NewBacklogItemView(item *backlog.Item)
BacklogItemView {
return BacklogItemView{item.ID().String(), item.Name()}
}

roblaszczak
148
SOLID Motivational Posters by Derick Bailey, used under CC BY-SA 3.0 US

roblaszczak
149
PERSYSTENTNE
REPOZYTORIUM

roblaszczak
152
Jak unmarshalować
obiekt domenowy bez
zbytniej ingerencji?

roblaszczak
153type ItemUnmarshalData struct {
ID ItemID
Name string
Status ItemStatus
ReleaseSchedule time.Time
CommitedSprintID sprint.ID
}
func UnmarshalItem(ud ItemUnmarshalData) *Item {
return &Item{
ud.ID,
ud.Name,
ud.Status,
ud.ReleaseSchedule,
ud.CommitedSprintID,
}
}

roblaszczak
154type ItemUnmarshalData struct {
ID ItemID
Name string
Status ItemStatus
ReleaseSchedule time.Time
CommitedSprintID sprint.ID
}
func UnmarshalItem(ud ItemUnmarshalData) *Item {
return &Item{
ud.ID,
ud.Name,
ud.Status,
ud.ReleaseSchedule,
ud.CommitedSprintID,
}
}

roblaszczak
155
ANEMICZNY
MODEL

roblaszczak
156
type User struct {
id ID
email string
name string
address string
}
func (u *User) Id() ID { return u.id }
func (u *User) SetId(id ID) { u.id = id }
func (u *User) Email() string { return u.email }
func (u *User) SetEmail(email string) { u.email = email }
func (u *User) Name() string { return u.name }
func (u *User) SetName(name string) { u.name = name }
func (u *User) Address() string { return u.address }
func (u *User) SetAddress(address string) { u.address = address }

roblaszczak
157
SILVER BULLET
NIE ISTNIEJE
DDD TEGO NIE ZMIENI

roblaszczak
161
Wrzucę linki na Twitterze
roblaszczak

roblaszczak
165
https://threedots.tech/

roblaszczak
Three Dots Labs
hire us!

roblaszczak
github.com/ThreeDotsLabs/watermill/

roblaszczak
DZIĘKI!
roblaszczak
robert@threedotslabs.com

Tactical DDD patterns in Go

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Semelhante a Tactical DDD patterns in Go

Semelhante a Tactical DDD patterns in Go (20)

Último

Último (20)

Tactical DDD patterns in Go