package module
Version: v0.0.0-...-a780941 Latest Latest

This package is not in the latest version of its module.

Go to latest
Published: Oct 20, 2016 License: Apache-2.0 Imports: 2 Imported by: 0


Domain Events


This is a package with several implementations for handling Domain events. In Domain Driven Design, a domain event is a way of indicating that some event has happened that has relevance to the domain.

This specific package provides the interfaces for interacting with these events as a part of a larger application.


go get


This library is designed to take advantage of a Four-layered Architecture. The specific publishers/subscribers in-use are a infrastructure concern. These are injected into the application layer as dependencies and the domain layer handles the hooks for when events are triggered.


In order to have your entity trigger a domain event automatically, you need to implement the appropriate interface as below:

  • BeforeCreate() *events.Event
  • AfterCreate() *events.Event
  • BeforeUpdate() *events.Event
  • AfterUpdate() *events.Event
  • BeforeDelete() *events.Event
  • AfterDelete() *events.Event

It'll look something like:

package domain

import (


type Something struct {
    All    string
    Sorts  string
    Of     string
    Params string

func (s *Something) AfterUpdate() *events.Event {
    return &events.Event{
        UUID:      "Something of significance",
        CreatedAt: time.Now(),
        Name:      "SomethingUpdated",
        Data:      map[string]string{
            "anything": "that we want to capture",
            "can":      "be reflected in this because",
            "type":     "is interface{}"

Then generate the repository using the evt tool.

evt -e domain/model/something/something.go -r infrastructure/persistence/db/something_repository_gen.go

It'll create a SomethingRepository for you that automatically hooks up the change hooks. In your service locator, instantiate the repository you generated:

func (c *Container) SomethingRepository() *db.SomethingRepository {
    if c.somethingRepo == nil {
        c.somethingRepo := &db.SomethingRepository{
            DB:  c.Database(),
            Pub: c.DomainEventsPublisher(),

    return c.somethingRepo

And when you call SomethingRepository.Save(*Something), it'll automatically call *Something.AfterUpdate for you. It does this without reflection because you've already generated the code. This means it's very quick!

The generated file is overwritten every time you run evt so it shouldn't be modified. If you need your repository to have custom behavior, create another file that implements the new methods you need. The generated repository is exported and can be extended with new func (r *SomethingRepository) YourMethod definitions.

Listen for the events elsewhere. Say a background job cli:

package main

import (


func handleSomethingUpdated(event *events.Event) error {
    fmt.Println("It's all good!")
    return nil

func main() {
    listener := container.DomainEventsListener()
    listener.RegisterHandler("SomethingUpdated", handleSomethingUpdated)




Package events provides interfaces for publishing and handling domain events in Go. In Domain Driven Design, a domain event is a way of indicating that some event has happened that has relevance to the domain.



This section is empty.


This section is empty.


This section is empty.


type AfterCreateHook

type AfterCreateHook interface {
	AfterCreate() *Event

AfterCreateHook is used for entities to trigger events after being created

type AfterDeleteHook

type AfterDeleteHook interface {
	AfterDelete() *Event

AfterDeleteHook is used for entities to trigger events after being deleted

type AfterUpdateHook

type AfterUpdateHook interface {
	AfterUpdate() *Event

AfterUpdateHook is used for entities to trigger events after being updated

type BeforeCreateHook

type BeforeCreateHook interface {
	BeforeCreate() *Event

BeforeCreateHook is used for entities to trigger events before being created

type BeforeDeleteHook

type BeforeDeleteHook interface {
	BeforeDelete() *Event

BeforeDeleteHook is used for entities to trigger events before being deleted

type BeforeUpdateHook

type BeforeUpdateHook interface {
	BeforeUpdate() *Event

BeforeUpdateHook is used for entities to trigger events before being updated

type ErrorHandler

type ErrorHandler func(error)

ErrorHandler defines the function signature required for handling errors

type Event

type Event struct {
	UUID      string      `json:"uuid"`
	CreatedAt time.Time   `json:"created_at"`
	Name      string      `json:"name"`
	Data      interface{} `json:"data"`

Event is a generic wrapper for all domain events

func NewEvent

func NewEvent(name string, payload interface{}) *Event

NewEvent creates a new event with the given name and payload. The UUID and CreatedAt fields are filled in automatically so that the infrastructure concerns of doing so are removed from the domain

type EventHandler

type EventHandler func(*Event) error

EventHandler defines the function signature required for handling events

type Listener

type Listener interface {
	// RegisterHandler registers an event handler for events of the given string name
	RegisterHandler(string, EventHandler)

	// Listen spawns a non-blocking goroutine to listen for new events

	// Halt stops the listen goroutine

Listener defines the interface required for listening for new events and handling them

type Publisher

type Publisher interface {
	// Publish pushes out the given event to the configured messaging interface
	Publish(*Event) error

Publisher describes the interface for pushing events


Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL