sqlite

README

SQLite Hexade

SQLite Repository The Hexades architecture uses a local bus with events which contain (a) a channel to send data back to the caller (errors and data) and (b) a higher order function to execute. The function is executed receving the repository and the data. This function is customizable to a client's specific requirements and would be the equivalent, perhaps, of an adapter in pure imperative hexagonal architecture which doesn't use messaging.

type Insert struct {
    bus.Event
    value      any
    insertFunc InsertFunction
}

This is the extent of the repository logic! It receives the event on a channel, verifies it is an SQLite event, and then simply calls execute on the event passing itself in. The Execute method in turn calls the InsertFunc and executes the logic.

func (r *repository) OnRepositoryEvent(repositoryChannel <-chan bus.RepositoryEvent) {

    for repoEvent := range repositoryChannel {
        switch evt := repoEvent.(type) {
        case SQLiteEvent:
            evt.Execute(r)
        }
    }
}

The basic insert function is where things can get interesting in the future. The event, the repository and all the plumbing stay the same but if I want some different handling of the insert, I simply inject a different function. An update is even a better example, perhaps, as I may need to look up some values first before updating. In any case, this is the highly customizable part. Just inject a different function into the event and you change the behavior.

var BasicInsertFunc = func(event *Insert, repo *repository) {
    value := event.value
    tx := repo.db.Create(value)
    event.Send(bus.NewResponse(value, tx.Error))
}

The final step in the function is to call Send on the event. That actually puts the response on a channel in the event and the receiver can listen for it and block while all the other processing happens concurrently or in parallel.

Documentation

Index

• Variables
• func AddListener(EventListener EventListener)
• func NewRepository()
• func SendEvent(Event Event)
• type Event
  • func NewEvent(value any, executable Executable) Event
• type EventListener
• type EventModel
  • func (e *EventModel) Execute(repo *Repository)
  • func (e *EventModel) Receive() Response
  • func (e *EventModel) Send(val Response)
• type Executable
• type Model
  • func (m *Model) String() string
• type Repository
  • func (r *Repository) OnEvent(repositoryChannel <-chan Event)
• type Response
  • func NewResponse(value any, err error) Response

Variables

var BasicDeleteFunc = func(data *Model, repo *Repository) Response {
	value := data.Value
	tx := repo.db.Delete(value)
	return NewResponse(value, tx.Error)
}

var BasicInsertFunc = func(data *Model, repo *Repository) Response {
	value := data.Value

	repo.db.AutoMigrate(&value)
	tx := repo.db.Create(value)
	return NewResponse(value, tx.Error)
}

var BasicOpenFunc = func(data *Model, repo *Repository) Response {
	log.Println("Received open: ", data)
	db, err := gorm.Open(sqlite.Open(data.String()), &gorm.Config{})
	if err != nil {
		panic(err)
	}
	repo.db = db
	return NewResponse(repo.db, err)
}

var BasicUpdateFunc = func(data *Model, repo *Repository) Response {
	value := data.Value
	tx := repo.db.Updates(value)
	return NewResponse(value, tx.Error)
}

var ReadFirstFunc = func(data *Model, repo *Repository) Response {
	value := data.Value
	tx := repo.db.First(value)
	return NewResponse(value, tx.Error)
}

Functions

func AddListener

func AddListener(EventListener EventListener)

func NewRepository

func NewRepository()

func SendEvent

func SendEvent(Event Event)

Types

type Event

type Event interface {
	Execute(repo *Repository)
	Send(Response)
	Receive() Response
}

func NewEvent

func NewEvent(value any, executable Executable) Event

type EventListener

type EventListener interface {
	OnEvent(Event <-chan Event)
}

type EventModel

type EventModel struct {
	// contains filtered or unexported fields
}

func (*EventModel) Execute

func (e *EventModel) Execute(repo *Repository)

func (*EventModel) Receive

func (e *EventModel) Receive() Response

func (*EventModel) Send

func (e *EventModel) Send(val Response)

type Executable

type Executable = func(data *Model, repo *Repository) Response

type Model

type Model struct {
	Value any
}

func (*Model) String

func (m *Model) String() string

type Repository

type Repository struct {
	// contains filtered or unexported fields
}

func (*Repository) OnEvent

func (r *Repository) OnEvent(repositoryChannel <-chan Event)

type Response

type Response struct {
	Value any
	Err   error
}

func NewResponse

func NewResponse(value any, err error) Response