type AggregateBase struct {
	ID string
	events []Event
}

func (a *AggregateBase) AddEvent(event Event) {
	a.events = append(a.events, event)
}

func (a *AggregateBase) GetID() string {
	return a.ID
}

func (a *AggregateBase) GetEvents() []Event {
	return a.events
}

    // CreateOrder
    order.AddEvent(&OrderCreated{
		Order: order,
	})

package domain

type OrderCreated struct {
	Order *Order
}

func (OrderCreated) EventName() string {
	return "orders.OrderCreated"
}

type CreateOrderHandler struct {
	orders          domain.OrderRepository
+	domainPublisher ddd.Publisher
}

+ func NewCreateOrderHandler(orders domain.OrderRepository, domainPublisher ddd.Publisher) CreateOrderHandler {
	return CreateOrderHandler{
		orders:          orders,
+		domainPublisher: domainPublisher,
	}
}

func (h CreateOrderHandler) CreateOrder(ctx context.Context, cmd CreateOrder) error {
	order, err := domain.NewOrder(cmd.ID, cmd.BuyerID, cmd.OrderedAt, cmd.OrderItems, cmd.TotalPrice)
	if err != nil {
		return err
	}

	err = h.orders.Save(ctx, order)
	if err != nil {
		return err
	}

+	if err = h.domainPublisher.Publish(ctx, order.GetEvents()...); err != nil {
+		return err
+	}

	return nil
}

orderCreated := event.(*domain.OrderCreated)

type EventPayload interface{}

type EventOptions interface {
	configureEvent(*event)
}

type Event interface {
	ID() string
	EventName() string
	Payload() EventPayload
	Metadata() Metadata
	OccurredAt() time.Time
}

type event struct {
	id         string
	name       string
	payload    EventPayload
	metadata   Metadata
	occurredAt time.Time
}

var _ Event = (*event)(nil)

type EventHandler func(ctx context.Context, event Event) error

func NewEvent(name string, payload EventPayload, options ...EventOptions) event {
	e := event{
		id:         uuid.New().String(),
		name:       name,
		payload:    payload,
		metadata:   make(Metadata),
		occurredAt: time.Now(),
	}

	for _, option := range options {
		option.configureEvent(&e)
	}
	return e
}

func (e event) ID() string            { return e.id }
func (e event) EventName() string     { return e.name }
func (e event) Payload() EventPayload { return e.payload }
func (e event) Metadata() Metadata    { return e.metadata }
func (e event) OccurredAt() time.Time { return e.occurredAt }

-func (a *AggregateBase) AddEvent(event Event) {
-       a.events = append(a.events, event)
+type AggregateEvent interface {
+       Event
+       AggregateName() string
+       AggregateID() string
+       AggregateVersion() int
+}
+
+type aggregateEvent struct {
+       event
+}
+
+var _ AggregateEvent = (*aggregateEvent)(nil)
+
+const (
+       AggregateNameKey    = "aggregate-name"
+       AggregateIDKey      = "aggregate-id"
+       AggregateVersionKey = "aggregate-version"
+)
+
+func (a *AggregateBase) AddEvent(name string, payload EventPayload, options ...EventOption) {
+       options = append(
+               options,
+               Metadata{
+                       AggregateNameKey: a.name,
+                       AggregateIDKey:   a.id,
+               },
+       )
+       a.events = append(
+               a.events,
+               aggregateEvent{
+                       event: NewEvent(name, payload, options...),
+               },
+       )
 }

+
+func (e aggregateEvent) AggregateName() string { return e.metadata.Get(AggregateNameKey).(string) }
+func (e aggregateEvent) AggregateID() string   { return e.metadata.Get(AggregateIDKey).(string) }
+func (e aggregateEvent) AggregateVersion() int { return e.metadata.Get(AggregateVersionKey).(int) }

type Aggregate struct {
	ddd.Aggregate
	version int
}

func NewAggregate(id, name string) Aggregate {
	return Aggregate{
		Aggregate: ddd.NewAggregate(id, name),
		version:   0,
	}
}

func (a *Aggregate) AddEvent(
	name string,
	payload ddd.EventPayload,
	options ...ddd.EventOption,
) {
	options = append(
		options,
		ddd.Metadata{
			ddd.AggregateVersionKey: a.PendingVersion() + 1,
		},
	)
}

func (a Aggregate) PendingVersion() int { return a.version + len(a.Events()) }

type Aggregate struct {
	ddd.Aggregate
	version int
}

func (a *Aggregate) AddEvent(
	name string,
	payload ddd.EventPayload,
	options ...ddd.EventOption,
) {
	options = append(
		options,
		ddd.Metadata{
			ddd.AggregateVersionKey: a.PendingVersion() + 1,
		},
	)
}

func (a Aggregate) PendingVersion() int { return a.version + len(a.Events()) }

func (a *Aggregate) CommitEvents() {
	a.version += len(a.Events())
	a.ClearEvents()
}

type AggregateEvent interface {
  Event
  AggregateName() string
  AggregateID() string
  AggregateVersion() int
}

func (a *Aggregate) AddEvent(name string, payload EventPayload, options ...EventOption) {
	options = append(
		options,
		Metadata{
			AggregateNameKey: a.name,
			AggregateIDKey:   a.id,
		},
	)
	a.events = append(
		a.events,
		aggregateEvent{
			event: NewEvent(name, payload, options...),
		},
	)
}

type Order struct {
-	ddd.AggregateBase
+	es.Aggregate
	BuyerID    string
	OrderedAt  time.Time
	OrderItems []*OrderItem
	Price       float64
}

-func (h GetOrderHandler) GetOrder(ctx context.Context, cmd GetOrder) (*domain.Order, error) {
-	order, err := h.orders.Find(ctx, cmd.ID, cmd.BuyerID)
+func (h GetOrderHandler) GetOrder(ctx context.Context, query GetOrder) (*domain.Order, error) {
+	order, err := h.orders.Load(ctx, query.ID)
	if err != nil {
		return nil, err
	}

type CreateOrderHandler struct {
	orders          domain.OrderRepository
-	domainPublisher ddd.Publisher
}

func (h CreateOrderHandler) CreateOrder(ctx context.Context, cmd CreateOrder) error {
	order, err := domain.CreateOrder(cmd.ID, cmd.BuyerID, cmd.OrderedAt, cmd.OrderItems, cmd.TotalPrice)
	if err != nil {
		return err
    }

-	if err = h.domainPublisher.Publish(ctx, order.GetEvents()...); err != nil {
-		return err
-	}
	return nil
}

// 他の部分は本質から外れるためSQL文のみ抽出
func (s EventStore) Load(ctx context.Context, aggregate es.EventSourcedAggregate) (err error) {
	const query = `SELECT stream_version, event_id, event_name, event_data, occurred_at FROM %s WHERE stream_id = $1 AND stream_name = $2 AND stream_version > $3 ORDER BY stream_version ASC`

	aggregateID := aggregate.ID()
	aggregateName := aggregate.AggregateName()

	var rows *sql.Rows

	rows, err = s.db.QueryContext(ctx, s.table(query), aggregateID, aggregateName, aggregate.Version())

func (s EventStore) Save(ctx context.Context, aggregate es.EventSourcedAggregate) error {
	const query = `INSERT INTO %s (stream_id, stream_name, stream_version, event_id, event_name, event_data, occurred_at) VALUES ($1, $2, $3, $4, $5, $6, $7)`
(中略)
	aggregateID := aggregate.ID()
	aggregateName := aggregate.AggregateName()
(中略)
	for _, event := range aggregate.Events() {
(中略)
			if _, err = tx.ExecContext(
			ctx, s.table(query)
			aggregateID, aggregateName, event.AggregateVersion(), event.ID(), event.EventName(), payloadData, event.OccurredAt(),

type EventSourcedAggregate interface {
	ID() string
	AggregateName() string
	AddEvent(string, ddd.EventPayload, ...ddd.EventOption)
	Events() []ddd.AggregateEvent
	ClearEvents()
	ApplyEvent(ddd.Event) error
	CommitEvents()
	Version() int
	PendingVersion() int
}

type AggregateStore interface {
	Load(ctx context.Context, aggregate EventSourcedAggregate) error
	Save(ctx context.Context, aggregate EventSourcedAggregate) error
}

type AggregateRepository[T EventSourcedAggregate] struct {
	aggregateName string
	registry      registry.Registry
	store         AggregateStore // Load, Saveの処理を移譲する
}

func (r AggregateRepository[T]) Load(
	ctx context.Context, aggregateID string,
) (agg T, err error) {
	var v any

    // レジストリの作成
	v, err = r.registry.Build(
		r.aggregateName,
		ddd.SetID(aggregateID),
		ddd.SetName(r.aggregateName),
	)
	if err != nil {
		return agg, err
	}

	var ok bool
    // 型検査
	if agg, ok = v.(T); !ok {
		return agg, fmt.Errorf("%T is not the expected type %T", v, agg)
	}

    // DBのクエリ
	if err = r.store.Load(ctx, agg); err != nil {
		return agg, err
	}

	return agg, nil
}

func (r *registry) register(key string, fn func() interface{}, s Serializer, d Deserializer, o []BuildOption) error {
	r.mu.Lock()
	defer r.mu.Unlock()

	if _, exists := r.registered[key]; exists {
		return errors.New(fmt.Sprintf("キーに対応するデータがすでに登録されています。key: %s", key))
	}

	r.registered[key] = registered{
		factory:      fn,
		serializer:   s,
		deserializer: d,
		options:      o,
	}

	return nil
}

type JsonSerde struct {
	r registry.Registry
}

var _ registry.Serde = (*JsonSerde)(nil)

func NewJsonSerde(r registry.Registry) *JsonSerde {
	return &JsonSerde{r: r}
}

func (c JsonSerde) Register(v registry.Registrable, options ...registry.BuildOption) error {
	return registry.Register(c.r, v, c.serialize, c.deserialize, options)
}

func (c JsonSerde) RegisterKey(key string, v interface{}, options ...registry.BuildOption) error {
	return registry.RegisterKey(c.r, key, v, c.serialize, c.deserialize, options)
}

func (c JsonSerde) RegisterFactory(key string, fn func() interface{}, options ...registry.BuildOption) error {
	return registry.RegisterFactory(c.r, key, fn, c.serialize, c.deserialize, options)
}

func (JsonSerde) serialize(v interface{}) ([]byte, error) {
	return json.Marshal(v)
}

func (JsonSerde) deserialize(data []byte, v interface{}) error {
	return json.Unmarshal(data, v)
}

func (r *registry) Build(key string, options ...BuildOption) (interface{}, error) {
	reg, exists := r.registered[key]
	if !exists {
		return nil, errors.New(fmt.Sprintf("キーに対応する値は登録されていません。key: %s", key))
	}

    // Factory Methodによってインスタンスを作成
	v := reg.factory()
	uos := append(r.registered[key].options, options...)

    // ビルドオプションとして与えられた関数をすべてインスタンスに適用
	for _, option := range uos {
		err := option(v)
		if err != nil {
			return nil, err
		}
	}

	return v, nil
}

func (r AggregateRepository[T]) Load(
	ctx context.Context, aggregateID string,
) (agg T, err error) {
	var v any
	v, err = r.registry.Build(
		r.aggregateName,
        // BuildOptionとしてsetID, setNameを与えることで、作成時に特定のIDとNameを付与する
		ddd.SetID(aggregateID),
		ddd.SetName(r.aggregateName),
	)
	if err != nil {
		return agg, err
	}

	var ok bool
	if agg, ok = v.(T); !ok {
		return agg, fmt.Errorf("%T is not the expected type %T", v, agg)
	}

	if err = r.store.Load(ctx, agg); err != nil {
		return agg, err
	}

	return agg, nil
}