zitadel/backend/v3/domain/invoke.go

package domain

import (
	"context"
	"fmt"

	"github.com/zitadel/zitadel/backend/v3/storage/eventstore"
)

// Invoke provides a way to execute commands within the domain package.
// It uses the [chain of responsibility](https://github.com/zitadel/zitadel/wiki/WIP:-Software-Architecture#chain-of-responsibility) pattern to handle the command execution.
// The default chain includes logging, tracing, and event publishing.
// If you want to invoke multiple commands in a single transaction, you can use the [commandBatch].
func Invoke(ctx context.Context, cmd Commander) error {
	invoker := newEventStoreInvoker(newLoggingInvoker(newTraceInvoker(nil)))
	opts := &CommandOpts{
		Invoker: invoker.collector,
		DB:      pool,
	}
	return invoker.Invoke(ctx, cmd, opts)
}

// eventStoreInvoker checks if the command implements the [eventer] interface.
// If it does, it collects the events and publishes them to the event store.
type eventStoreInvoker struct {
	collector *eventCollector
}

func newEventStoreInvoker(next Invoker) *eventStoreInvoker {
	return &eventStoreInvoker{collector: &eventCollector{next: next}}
}

// Invoke implements the [Invoker] interface.
func (i *eventStoreInvoker) Invoke(ctx context.Context, command Commander, opts *CommandOpts) (err error) {
	err = i.collector.Invoke(ctx, command, opts)
	if err != nil {
		return err
	}
	if len(i.collector.events) > 0 {
		err = eventstore.Publish(ctx, i.collector.events, opts.DB)
		if err != nil {
			return err
		}
	}
	return nil
}

// eventCollector collects events from all commands. The [eventStoreInvoker] pushes the collected events after all commands are executed.
type eventCollector struct {
	next   Invoker
	events []*eventstore.Event
}

type eventer interface {
	Events() []*eventstore.Event
}

// Invoke implements the [Invoker] interface.
func (i *eventCollector) Invoke(ctx context.Context, command Commander, opts *CommandOpts) (err error) {
	if e, ok := command.(eventer); ok && len(e.Events()) > 0 {
		// we need to ensure all commands are executed in the same transaction
		close, err := opts.EnsureTx(ctx)
		if err != nil {
			return err
		}
		defer func() { err = close(ctx, err) }()

		i.events = append(i.events, e.Events()...)
	}
	if i.next != nil {
		return i.next.Invoke(ctx, command, opts)
	}
	return command.Execute(ctx, opts)
}

// traceInvoker decorates each command with tracing.
type traceInvoker struct {
	next Invoker
}

func newTraceInvoker(next Invoker) *traceInvoker {
	return &traceInvoker{next: next}
}

// Invoke implements the [Invoker] interface.
func (i *traceInvoker) Invoke(ctx context.Context, command Commander, opts *CommandOpts) (err error) {
	ctx, span := tracer.Start(ctx, fmt.Sprintf("%T", command))
	defer func() {
		if err != nil {
			span.RecordError(err)
		}
		span.End()
	}()

	if i.next != nil {
		return i.next.Invoke(ctx, command, opts)
	}
	return command.Execute(ctx, opts)
}

// loggingInvoker decorates each command with logging.
// It is an example implementation and logs the command name at the beginning and success or failure after the command got executed.
type loggingInvoker struct {
	next Invoker
}

func newLoggingInvoker(next Invoker) *loggingInvoker {
	return &loggingInvoker{next: next}
}

// Invoke implements the [Invoker] interface.
func (i *loggingInvoker) Invoke(ctx context.Context, command Commander, opts *CommandOpts) (err error) {
	logger.InfoContext(ctx, "Invoking command", "command", command.String())

	if i.next != nil {
		err = i.next.Invoke(ctx, command, opts)
	} else {
		err = command.Execute(ctx, opts)
	}

	if err != nil {
		logger.ErrorContext(ctx, "Command invocation failed", "command", command.String(), "error", err)
		return err
	}
	logger.InfoContext(ctx, "Command invocation succeeded", "command", command.String())
	return nil
}

// noopInvoker executes the command without any additional decoration.
type noopInvoker struct {
	next Invoker
}

// Invoke implements the [Invoker] interface.
func (i *noopInvoker) Invoke(ctx context.Context, command Commander, opts *CommandOpts) error {
	if i.next != nil {
		return i.next.Invoke(ctx, command, opts)
	}
	return command.Execute(ctx, opts)
}

// cacheInvoker could be used in the future to do the caching.
// My goal would be to have two interfaces:
// - cacheSetter: which caches an object
// - cacheGetter: which gets an object from the cache, this should also skip the command execution
type cacheInvoker struct {
	next Invoker
}

type cacher interface {
	Cache(opts *CommandOpts)
}

// Invoke implements the [Invoker] interface.
func (i *cacheInvoker) Invoke(ctx context.Context, command Commander, opts *CommandOpts) (err error) {
	if c, ok := command.(cacher); ok {
		c.Cache(opts)
	}
	if i.next != nil {
		err = i.next.Invoke(ctx, command, opts)
	} else {
		err = command.Execute(ctx, opts)
	}
	return err
}