Eventstore (#22)

* feat: eventstore repository

* fix: remove gorm

* version

* feat: pkg

* feat: eventstore without eventstore-lib

* rename files

* gnueg

* fix: add object

* fix: global model

* feat(eventstore): sdk

* fix(eventstore): search query

* fix(eventstore): rename app to eventstore

* delete empty test

* remove unused func

* merge master

* fix(eventstore): tests

* fix(models): delete unused struct

* feat(eventstore): implemented push events

* feat(eventstore): overwrite context data

* feat(types): SQL-config

* feat(eventstore): options to overwrite editor

* Update internal/eventstore/models/field.go

Co-Authored-By: livio-a <livio.a@gmail.com>

* fix(eventstore): code quality

* fix(eventstore): rename modifier* to editor*

* fix(eventstore): delete editor_org

Co-authored-by: Fabiennne <fabienne.gerschwiler@gmail.com>
Co-authored-by: livio-a <livio.a@gmail.com>

internal/eventstore/models/aggregate.go

@@ -0,0 +1,88 @@
+package models
+
+import (
+	"time"
+
+	"github.com/caos/zitadel/internal/errors"
+)
+
+type AggregateType string
+
+func (at AggregateType) String() string {
+	return string(at)
+}
+
+type Aggregates []*Aggregate
+
+type Aggregate struct {
+	id             string
+	typ            AggregateType
+	latestSequence uint64
+	version        Version
+
+	editorService string
+	editorUser    string
+	resourceOwner string
+	Events        []*Event
+	Appender      appender
+}
+
+type appender func(...*Event)
+
+func (a *Aggregate) AppendEvent(typ EventType, payload interface{}) (*Aggregate, error) {
+	if string(typ) == "" {
+		return a, errors.ThrowInvalidArgument(nil, "MODEL-TGoCb", "no event type")
+	}
+	data, err := eventData(payload)
+	if err != nil {
+		return a, err
+	}
+
+	e := &Event{
+		CreationDate:     time.Now(),
+		Data:             data,
+		Type:             typ,
+		PreviousSequence: a.latestSequence,
+		AggregateID:      a.id,
+		AggregateType:    a.typ,
+		AggregateVersion: a.version,
+		EditorService:    a.editorService,
+		EditorUser:       a.editorUser,
+		ResourceOwner:    a.resourceOwner,
+	}
+
+	a.Events = append(a.Events, e)
+	return a, nil
+}
+
+func (a *Aggregate) Validate() error {
+	if a == nil {
+		return errors.ThrowPreconditionFailed(nil, "MODEL-yi5AC", "aggregate is nil")
+	}
+	if a.id == "" {
+		return errors.ThrowPreconditionFailed(nil, "MODEL-FSjKV", "id not set")
+	}
+	if string(a.typ) == "" {
+		return errors.ThrowPreconditionFailed(nil, "MODEL-aj4t2", "type not set")
+	}
+	if err := a.version.Validate(); err != nil {
+		return errors.ThrowPreconditionFailed(err, "MODEL-PupjX", "invalid version")
+	}
+
+	if a.editorService == "" {
+		return errors.ThrowPreconditionFailed(nil, "MODEL-clYbY", "editor service not set")
+	}
+	if a.editorUser == "" {
+		return errors.ThrowPreconditionFailed(nil, "MODEL-Xcssi", "editor user not set")
+	}
+	if a.resourceOwner == "" {
+		return errors.ThrowPreconditionFailed(nil, "MODEL-eBYUW", "resource owner not set")
+	}
+
+	return nil
+}
+
+func (a *Aggregate) SetAppender(appendFn appender) *Aggregate {
+	a.Appender = appendFn
+	return a
+}

internal/eventstore/models/aggregate_creator.go

@@ -0,0 +1,56 @@
+package models
+
+import (
+	"context"
+
+	"github.com/caos/zitadel/internal/api/auth"
+)
+
+type AggregateCreator struct {
+	serviceName string
+}
+
+func NewAggregateCreator(serviceName string) *AggregateCreator {
+	return &AggregateCreator{serviceName: serviceName}
+}
+
+type option func(*Aggregate)
+
+func (c *AggregateCreator) NewAggregate(ctx context.Context, id string, typ AggregateType, version Version, latestSequence uint64, opts ...option) (*Aggregate, error) {
+	ctxData := auth.GetCtxData(ctx)
+	editorUser := ctxData.UserID
+	resourceOwner := ctxData.OrgID
+
+	aggregate := &Aggregate{
+		id:             id,
+		typ:            typ,
+		latestSequence: latestSequence,
+		version:        version,
+		Events:         make([]*Event, 0, 2),
+		editorService:  c.serviceName,
+		editorUser:     editorUser,
+		resourceOwner:  resourceOwner,
+	}
+
+	for _, opt := range opts {
+		opt(aggregate)
+	}
+
+	if err := aggregate.Validate(); err != nil {
+		return nil, err
+	}
+
+	return aggregate, nil
+}
+
+func OverwriteEditorUser(userID string) func(*Aggregate) {
+	return func(a *Aggregate) {
+		a.editorUser = userID
+	}
+}
+
+func OverwriteResourceOwner(resourceOwner string) func(*Aggregate) {
+	return func(a *Aggregate) {
+		a.resourceOwner = resourceOwner
+	}
+}

internal/eventstore/models/aggregate_creator_test.go

@@ -0,0 +1,118 @@
+package models
+
+import (
+	"context"
+	"reflect"
+	"testing"
+)
+
+func TestAggregateCreator_NewAggregate(t *testing.T) {
+	type args struct {
+		ctx     context.Context
+		id      string
+		typ     AggregateType
+		version Version
+		opts    []option
+	}
+	tests := []struct {
+		name    string
+		creator *AggregateCreator
+		args    args
+		want    *Aggregate
+		wantErr bool
+	}{
+		{
+			name:    "no ctxdata and no options",
+			creator: &AggregateCreator{serviceName: "admin"},
+			wantErr: true,
+			want:    nil,
+			args: args{
+				ctx:     context.Background(),
+				id:      "hodor",
+				typ:     "user",
+				version: "v1.0.0",
+			},
+		},
+		{
+			name:    "no id error",
+			creator: &AggregateCreator{serviceName: "admin"},
+			wantErr: true,
+			want:    nil,
+			args: args{
+				ctx:     context.Background(),
+				typ:     "user",
+				version: "v1.0.0",
+				opts: []option{
+					OverwriteEditorUser("hodor"),
+					OverwriteResourceOwner("org"),
+				},
+			},
+		},
+		{
+			name:    "no type error",
+			creator: &AggregateCreator{serviceName: "admin"},
+			wantErr: true,
+			want:    nil,
+			args: args{
+				ctx:     context.Background(),
+				id:      "hodor",
+				version: "v1.0.0",
+				opts: []option{
+					OverwriteEditorUser("hodor"),
+					OverwriteResourceOwner("org"),
+				},
+			},
+		},
+		{
+			name:    "invalid version error",
+			creator: &AggregateCreator{serviceName: "admin"},
+			wantErr: true,
+			want:    nil,
+			args: args{
+				ctx: context.Background(),
+				id:  "hodor",
+				typ: "user",
+				opts: []option{
+					OverwriteEditorUser("hodor"),
+					OverwriteResourceOwner("org"),
+				},
+			},
+		},
+		{
+			name:    "create ok",
+			creator: &AggregateCreator{serviceName: "admin"},
+			wantErr: false,
+			want: &Aggregate{
+				id:            "hodor",
+				Events:        make([]*Event, 0, 2),
+				typ:           "user",
+				version:       "v1.0.0",
+				editorService: "admin",
+				editorUser:    "hodor",
+				resourceOwner: "org",
+			},
+			args: args{
+				ctx:     context.Background(),
+				id:      "hodor",
+				typ:     "user",
+				version: "v1.0.0",
+				opts: []option{
+					OverwriteEditorUser("hodor"),
+					OverwriteResourceOwner("org"),
+				},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := tt.creator.NewAggregate(tt.args.ctx, tt.args.id, tt.args.typ, tt.args.version, 0, tt.args.opts...)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("AggregateCreator.NewAggregate() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("AggregateCreator.NewAggregate() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

internal/eventstore/models/aggregate_test.go

@@ -0,0 +1,173 @@
+package models
+
+import (
+	"testing"
+)
+
+func TestAggregate_AppendEvent(t *testing.T) {
+	type fields struct {
+		aggregate *Aggregate
+	}
+	type args struct {
+		typ     EventType
+		payload interface{}
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		args    args
+		want    *Aggregate
+		wantErr bool
+	}{
+		{
+			name:    "no event type error",
+			fields:  fields{aggregate: &Aggregate{}},
+			args:    args{},
+			want:    &Aggregate{},
+			wantErr: true,
+		},
+		{
+			name:    "invalid payload error",
+			fields:  fields{aggregate: &Aggregate{}},
+			args:    args{typ: "user", payload: 134},
+			want:    &Aggregate{},
+			wantErr: true,
+		},
+		{
+			name:    "event added",
+			fields:  fields{aggregate: &Aggregate{Events: []*Event{}}},
+			args:    args{typ: "user.deactivated"},
+			want:    &Aggregate{Events: []*Event{&Event{Type: "user.deactivated"}}},
+			wantErr: false,
+		},
+		{
+			name:    "event added",
+			fields:  fields{aggregate: &Aggregate{Events: []*Event{&Event{}}}},
+			args:    args{typ: "user.deactivated"},
+			want:    &Aggregate{Events: []*Event{&Event{}, &Event{Type: "user.deactivated"}}},
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := tt.fields.aggregate.AppendEvent(tt.args.typ, tt.args.payload)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Aggregate.AppendEvent() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if len(tt.fields.aggregate.Events) != len(got.Events) {
+				t.Errorf("events len should be %d but was %d", len(tt.fields.aggregate.Events), len(got.Events))
+			}
+		})
+	}
+}
+
+func TestAggregate_Validate(t *testing.T) {
+	type fields struct {
+		aggregate *Aggregate
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		wantErr bool
+	}{
+		{
+			name:    "aggregate nil error",
+			wantErr: true,
+		},
+		{
+			name:    "aggregate empty error",
+			wantErr: true,
+			fields:  fields{aggregate: &Aggregate{}},
+		},
+		{
+			name:    "no id error",
+			wantErr: true,
+			fields: fields{aggregate: &Aggregate{
+				typ:            "user",
+				version:        "v1.0.0",
+				editorService:  "svc",
+				editorUser:     "hodor",
+				resourceOwner:  "org",
+				latestSequence: 5,
+				Events: []*Event{&Event{
+					AggregateType:    "user",
+					AggregateVersion: "v1.0.0",
+					EditorService:    "management",
+					EditorUser:       "hodor",
+					ResourceOwner:    "org",
+					Type:             "born",
+				}},
+			}},
+		},
+		{
+			name:    "no type error",
+			wantErr: true,
+			fields: fields{aggregate: &Aggregate{
+				id:             "aggID",
+				version:        "v1.0.0",
+				editorService:  "svc",
+				editorUser:     "hodor",
+				resourceOwner:  "org",
+				latestSequence: 5,
+				Events: []*Event{&Event{
+					AggregateID:      "hodor",
+					AggregateVersion: "v1.0.0",
+					EditorService:    "management",
+					EditorUser:       "hodor",
+					ResourceOwner:    "org",
+					Type:             "born",
+				}},
+			}},
+		},
+		{
+			name:    "invalid version error",
+			wantErr: true,
+			fields: fields{aggregate: &Aggregate{
+				id:             "aggID",
+				typ:            "user",
+				editorService:  "svc",
+				editorUser:     "hodor",
+				resourceOwner:  "org",
+				latestSequence: 5,
+				Events: []*Event{&Event{
+					AggregateID:   "hodor",
+					AggregateType: "user",
+					EditorService: "management",
+					EditorUser:    "hodor",
+					ResourceOwner: "org",
+					Type:          "born",
+				}},
+			}},
+		},
+		{
+			name:    "validation ok",
+			wantErr: false,
+			fields: fields{aggregate: &Aggregate{
+				id:             "aggID",
+				typ:            "user",
+				version:        "v1.0.0",
+				editorService:  "svc",
+				editorUser:     "hodor",
+				resourceOwner:  "org",
+				latestSequence: 5,
+				Events: []*Event{&Event{
+					AggregateID:      "hodor",
+					AggregateType:    "user",
+					AggregateVersion: "v1.0.0",
+					EditorService:    "management",
+					EditorUser:       "hodor",
+					ResourceOwner:    "org",
+					Type:             "born",
+				}},
+			}},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := tt.fields.aggregate.Validate(); (err != nil) != tt.wantErr {
+				t.Errorf("Aggregate.Validate() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}

internal/eventstore/models/event.go

@@ -0,0 +1,89 @@
+package models
+
+import (
+	"encoding/json"
+	"reflect"
+	"time"
+
+	"github.com/caos/zitadel/internal/errors"
+)
+
+type EventType string
+
+func (et EventType) String() string {
+	return string(et)
+}
+
+type Event struct {
+	ID               string
+	Sequence         uint64
+	CreationDate     time.Time
+	Type             EventType
+	PreviousSequence uint64
+	Data             []byte
+
+	AggregateID      string
+	AggregateType    AggregateType
+	AggregateVersion Version
+	EditorService    string
+	EditorUser       string
+	ResourceOwner    string
+}
+
+func eventData(i interface{}) ([]byte, error) {
+	switch v := i.(type) {
+	case []byte:
+		return v, nil
+	case map[string]interface{}:
+		bytes, err := json.Marshal(v)
+		if err != nil {
+			return nil, errors.ThrowInvalidArgument(err, "MODEL-s2fgE", "unable to marshal data")
+		}
+		return bytes, nil
+	case nil:
+		return nil, nil
+	default:
+		t := reflect.TypeOf(i)
+		if t.Kind() == reflect.Ptr {
+			t = t.Elem()
+		}
+		if t.Kind() != reflect.Struct {
+			return nil, errors.ThrowInvalidArgument(nil, "MODEL-rjWdN", "data is not valid")
+		}
+		bytes, err := json.Marshal(v)
+		if err != nil {
+			return nil, errors.ThrowInvalidArgument(err, "MODEL-Y2OpM", "unable to marshal data")
+		}
+		return bytes, nil
+	}
+}
+
+func (e *Event) Validate() error {
+	if e == nil {
+		return errors.ThrowPreconditionFailed(nil, "MODEL-oEAG4", "event is nil")
+	}
+	if string(e.Type) == "" {
+		return errors.ThrowPreconditionFailed(nil, "MODEL-R2sB0", "type not defined")
+	}
+
+	if e.AggregateID == "" {
+		return errors.ThrowPreconditionFailed(nil, "MODEL-A6WwL", "aggregate id not set")
+	}
+	if e.AggregateType == "" {
+		return errors.ThrowPreconditionFailed(nil, "MODEL-EzdyK", "aggregate type not set")
+	}
+	if err := e.AggregateVersion.Validate(); err != nil {
+		return err
+	}
+
+	if e.EditorService == "" {
+		return errors.ThrowPreconditionFailed(nil, "MODEL-4Yqik", "editor service not set")
+	}
+	if e.EditorUser == "" {
+		return errors.ThrowPreconditionFailed(nil, "MODEL-L3NHO", "editor user not set")
+	}
+	if e.ResourceOwner == "" {
+		return errors.ThrowPreconditionFailed(nil, "MODEL-omFVT", "resource ow")
+	}
+	return nil
+}

internal/eventstore/models/event_test.go

@@ -0,0 +1,198 @@
+package models
+
+import (
+	"reflect"
+	"testing"
+)
+
+func Test_eventData(t *testing.T) {
+	type args struct {
+		i interface{}
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    []byte
+		wantErr bool
+	}{
+		{
+			name:    "from bytes",
+			args:    args{[]byte(`{"hodor":"asdf"}`)},
+			want:    []byte(`{"hodor":"asdf"}`),
+			wantErr: false,
+		},
+		{
+			name: "from pointer",
+			args: args{&struct {
+				Hodor string `json:"hodor"`
+			}{Hodor: "asdf"}},
+			want:    []byte(`{"hodor":"asdf"}`),
+			wantErr: false,
+		},
+		{
+			name: "from struct",
+			args: args{struct {
+				Hodor string `json:"hodor"`
+			}{Hodor: "asdf"}},
+			want:    []byte(`{"hodor":"asdf"}`),
+			wantErr: false,
+		},
+		{
+			name: "from map",
+			args: args{
+				map[string]interface{}{"hodor": "asdf"},
+			},
+			want:    []byte(`{"hodor":"asdf"}`),
+			wantErr: false,
+		},
+		{
+			name:    "from nil",
+			args:    args{},
+			want:    nil,
+			wantErr: false,
+		},
+		{
+			name:    "invalid data",
+			args:    args{876},
+			want:    nil,
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := eventData(tt.args.i)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("eventData() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("eventData() = %s, want %s", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestEvent_Validate(t *testing.T) {
+	type fields struct {
+		event *Event
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		wantErr bool
+	}{
+		{
+			name:    "event nil",
+			wantErr: true,
+		},
+		{
+			name:    "event empty",
+			fields:  fields{event: &Event{}},
+			wantErr: true,
+		},
+		{
+			name: "no aggregate id",
+			fields: fields{event: &Event{
+				AggregateType:    "user",
+				AggregateVersion: "v1.0.0",
+				EditorService:    "management",
+				EditorUser:       "hodor",
+				ResourceOwner:    "org",
+				Type:             "born",
+			}},
+			wantErr: true,
+		},
+		{
+			name: "no aggregate type",
+			fields: fields{event: &Event{
+				AggregateID:      "hodor",
+				AggregateVersion: "v1.0.0",
+				EditorService:    "management",
+				EditorUser:       "hodor",
+				ResourceOwner:    "org",
+				Type:             "born",
+			}},
+			wantErr: true,
+		},
+		{
+			name: "no aggregate version",
+			fields: fields{event: &Event{
+				AggregateID:   "hodor",
+				AggregateType: "user",
+				EditorService: "management",
+				EditorUser:    "hodor",
+				ResourceOwner: "org",
+				Type:          "born",
+			}},
+			wantErr: true,
+		},
+		{
+			name: "no editor service",
+			fields: fields{event: &Event{
+				AggregateID:      "hodor",
+				AggregateType:    "user",
+				AggregateVersion: "v1.0.0",
+				EditorUser:       "hodor",
+				ResourceOwner:    "org",
+				Type:             "born",
+			}},
+			wantErr: true,
+		},
+		{
+			name: "no editor user",
+			fields: fields{event: &Event{
+				AggregateID:      "hodor",
+				AggregateType:    "user",
+				AggregateVersion: "v1.0.0",
+				EditorService:    "management",
+				ResourceOwner:    "org",
+				Type:             "born",
+			}},
+			wantErr: true,
+		},
+		{
+			name: "no resource owner",
+			fields: fields{event: &Event{
+				AggregateID:      "hodor",
+				AggregateType:    "user",
+				AggregateVersion: "v1.0.0",
+				EditorService:    "management",
+				EditorUser:       "hodor",
+				Type:             "born",
+			}},
+			wantErr: true,
+		},
+		{
+			name: "no type",
+			fields: fields{event: &Event{
+				AggregateID:      "hodor",
+				AggregateType:    "user",
+				AggregateVersion: "v1.0.0",
+				EditorService:    "management",
+				EditorUser:       "hodor",
+				ResourceOwner:    "org",
+			}},
+			wantErr: true,
+		},
+		{
+			name: "all fields set",
+			fields: fields{event: &Event{
+				AggregateID:      "hodor",
+				AggregateType:    "user",
+				AggregateVersion: "v1.0.0",
+				EditorService:    "management",
+				EditorUser:       "hodor",
+				ResourceOwner:    "org",
+				Type:             "born",
+			}},
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := tt.fields.event.Validate(); (err != nil) != tt.wantErr {
+				t.Errorf("Event.Validate() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}

internal/eventstore/models/field.go

@@ -0,0 +1,12 @@
+package models
+
+type Field int32
+
+const (
+	Field_AggregateType Field = 1 + iota
+	Field_AggregateID
+	Field_LatestSequence
+	Field_ResourceOwner
+	Field_ModifierService
+	Field_ModifierUser
+)

internal/eventstore/models/filter.go

@@ -0,0 +1,46 @@
+package models
+
+import (
+	"github.com/caos/zitadel/internal/errors"
+)
+
+type Filter struct {
+	field     Field
+	value     interface{}
+	operation Operation
+}
+
+//NewFilter is used in tests. Use searchQuery.*Filter() instead
+func NewFilter(field Field, value interface{}, operation Operation) *Filter {
+	return &Filter{
+		field:     field,
+		value:     value,
+		operation: operation,
+	}
+}
+
+func (f *Filter) GetField() Field {
+	return f.field
+}
+func (f *Filter) GetOperation() Operation {
+	return f.operation
+}
+func (f *Filter) GetValue() interface{} {
+	return f.value
+}
+
+func (f *Filter) Validate() error {
+	if f == nil {
+		return errors.ThrowPreconditionFailed(nil, "MODEL-z6KcG", "filter is nil")
+	}
+	if f.field <= 0 {
+		return errors.ThrowPreconditionFailed(nil, "MODEL-zw62U", "field not definded")
+	}
+	if f.value == nil {
+		return errors.ThrowPreconditionFailed(nil, "MODEL-GJ9ct", "no value definded")
+	}
+	if f.operation <= 0 {
+		return errors.ThrowPreconditionFailed(nil, "MODEL-RrQTy", "operation not definded")
+	}
+	return nil
+}

internal/eventstore/models/filter_test.go

@@ -0,0 +1,104 @@
+package models
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestNewFilter(t *testing.T) {
+	type args struct {
+		field     Field
+		value     interface{}
+		operation Operation
+	}
+	tests := []struct {
+		name string
+		args args
+		want *Filter
+	}{
+		{
+			name: "aggregateID equals",
+			args: args{
+				field:     Field_AggregateID,
+				value:     "hodor",
+				operation: Operation_Equals,
+			},
+			want: &Filter{field: Field_AggregateID, operation: Operation_Equals, value: "hodor"},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := NewFilter(tt.args.field, tt.args.value, tt.args.operation); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("NewFilter() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestFilter_Validate(t *testing.T) {
+	type fields struct {
+		field     Field
+		value     interface{}
+		operation Operation
+		isNil     bool
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		wantErr bool
+	}{
+		{
+			name: "correct filter",
+			fields: fields{
+				field:     Field_LatestSequence,
+				operation: Operation_Greater,
+				value:     uint64(235),
+			},
+			wantErr: false,
+		},
+		{
+			name:    "filter is nil",
+			fields:  fields{isNil: true},
+			wantErr: true,
+		},
+		{
+			name: "no field error",
+			fields: fields{
+				operation: Operation_Greater,
+				value:     uint64(235),
+			},
+			wantErr: true,
+		},
+		{
+			name: "no value error",
+			fields: fields{
+				field:     Field_LatestSequence,
+				operation: Operation_Greater,
+			},
+			wantErr: true,
+		},
+		{
+			name: "no operation error",
+			fields: fields{
+				field: Field_LatestSequence,
+				value: uint64(235),
+			},
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var f *Filter
+			if !tt.fields.isNil {
+				f = &Filter{
+					field:     tt.fields.field,
+					value:     tt.fields.value,
+					operation: tt.fields.operation,
+				}
+			}
+			if err := f.Validate(); (err != nil) != tt.wantErr {
+				t.Errorf("Filter.Validate() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}

internal/eventstore/models/object.go

@@ -0,0 +1,25 @@
+package models
+
+import (
+	"time"
+)
+
+type ObjectRoot struct {
+	ID           string    `json:"-"`
+	Sequence     uint64    `json:"-"`
+	CreationDate time.Time `json:"-"`
+	ChangeDate   time.Time `json:"-"`
+}
+
+func (o *ObjectRoot) AppendEvent(event *Event) {
+	if o.ID == "" {
+		o.ID = event.AggregateID
+	}
+
+	o.ChangeDate = event.CreationDate
+	if event.PreviousSequence == 0 {
+		o.CreationDate = o.ChangeDate
+	}
+
+	o.Sequence = event.Sequence
+}

internal/eventstore/models/object_test.go

@@ -0,0 +1,81 @@
+package models
+
+import (
+	"testing"
+	"time"
+)
+
+func TestObjectRoot_AppendEvent(t *testing.T) {
+	type fields struct {
+		ID           string
+		Sequence     uint64
+		CreationDate time.Time
+		ChangeDate   time.Time
+	}
+	type args struct {
+		event     *Event
+		isNewRoot bool
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		args   args
+	}{
+		{
+			"new root",
+			fields{},
+			args{
+				&Event{
+					AggregateID:  "aggID",
+					Sequence:     34555,
+					CreationDate: time.Now(),
+				},
+				true,
+			},
+		},
+		{
+			"existing root",
+			fields{
+				"agg",
+				234,
+				time.Now().Add(-24 * time.Hour),
+				time.Now().Add(-12 * time.Hour),
+			},
+			args{
+				&Event{
+					AggregateID:      "agg",
+					Sequence:         34555425,
+					CreationDate:     time.Now(),
+					PreviousSequence: 22,
+				},
+				false,
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			o := &ObjectRoot{
+				ID:           tt.fields.ID,
+				Sequence:     tt.fields.Sequence,
+				CreationDate: tt.fields.CreationDate,
+				ChangeDate:   tt.fields.ChangeDate,
+			}
+			o.AppendEvent(tt.args.event)
+			if tt.args.isNewRoot {
+				if !o.CreationDate.Equal(tt.args.event.CreationDate) {
+					t.Error("creationDate should be equal to event on new root")
+				}
+			} else {
+				if o.CreationDate.Equal(o.ChangeDate) {
+					t.Error("creationDate and changedate should differ")
+				}
+			}
+			if o.Sequence != tt.args.event.Sequence {
+				t.Errorf("sequence not equal to event: event: %d root: %d", tt.args.event.Sequence, o.Sequence)
+			}
+			if !o.ChangeDate.Equal(tt.args.event.CreationDate) {
+				t.Errorf("changedate should be equal to event creation date:  event: %v root: %v", tt.args.event.CreationDate, o.ChangeDate)
+			}
+		})
+	}
+}

internal/eventstore/models/operation.go

@@ -0,0 +1,10 @@
+package models
+
+type Operation int32
+
+const (
+	Operation_Equals Operation = 1 + iota
+	Operation_Greater
+	Operation_Less
+	Operation_In
+)

internal/eventstore/models/search_query.go

@@ -0,0 +1,74 @@
+package models
+
+import "github.com/caos/zitadel/internal/errors"
+
+type SearchQuery struct {
+	Limit   uint64
+	Desc    bool
+	Filters []*Filter
+}
+
+func NewSearchQuery() *SearchQuery {
+	return &SearchQuery{
+		Filters: make([]*Filter, 0, 4),
+	}
+}
+
+func (q *SearchQuery) SetLimit(limit uint64) *SearchQuery {
+	q.Limit = limit
+	return q
+}
+
+func (q *SearchQuery) OrderDesc() *SearchQuery {
+	q.Desc = true
+	return q
+}
+
+func (q *SearchQuery) OrderAsc() *SearchQuery {
+	q.Desc = false
+	return q
+}
+
+func (q *SearchQuery) AggregateIDFilter(id string) *SearchQuery {
+	return q.setFilter(NewFilter(Field_AggregateID, id, Operation_Equals))
+}
+
+func (q *SearchQuery) AggregateTypeFilter(types ...string) *SearchQuery {
+	return q.setFilter(NewFilter(Field_AggregateType, types, Operation_In))
+}
+
+func (q *SearchQuery) LatestSequenceFilter(sequence uint64) *SearchQuery {
+	sortOrder := Operation_Greater
+	if q.Desc {
+		sortOrder = Operation_Less
+	}
+	return q.setFilter(NewFilter(Field_LatestSequence, sequence, sortOrder))
+}
+
+func (q *SearchQuery) ResourceOwnerFilter(resourceOwner string) *SearchQuery {
+	return q.setFilter(NewFilter(Field_ResourceOwner, resourceOwner, Operation_Equals))
+}
+
+func (q *SearchQuery) setFilter(filter *Filter) *SearchQuery {
+	for i, f := range q.Filters {
+		if f.field == filter.field {
+			q.Filters[i] = filter
+			return q
+		}
+	}
+	q.Filters = append(q.Filters, filter)
+	return q
+}
+
+func (q *SearchQuery) Validate() error {
+	if q == nil {
+		return errors.ThrowPreconditionFailed(nil, "MODEL-J5xQi", "search query is nil")
+	}
+	for _, filter := range q.Filters {
+		if err := filter.Validate(); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

internal/eventstore/models/search_query_test.go

@@ -0,0 +1,59 @@
+package models
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestSearchQuery_setFilter(t *testing.T) {
+	type fields struct {
+		query *SearchQuery
+	}
+	type args struct {
+		filters []*Filter
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		args   args
+		want   *SearchQuery
+	}{
+		{
+			name:   "set idFilter",
+			fields: fields{query: NewSearchQuery()},
+			args:   args{filters: []*Filter{&Filter{field: Field_AggregateID, operation: Operation_Equals, value: "hodor"}}},
+			want:   &SearchQuery{Filters: []*Filter{&Filter{field: Field_AggregateID, operation: Operation_Equals, value: "hodor"}}},
+		},
+		{
+			name:   "overwrite idFilter",
+			fields: fields{query: NewSearchQuery()},
+			args: args{filters: []*Filter{
+				&Filter{field: Field_AggregateID, operation: Operation_Equals, value: "hodor"},
+				&Filter{field: Field_AggregateID, operation: Operation_Equals, value: "ursli"},
+			}},
+			want: &SearchQuery{Filters: []*Filter{&Filter{field: Field_AggregateID, operation: Operation_Equals, value: "ursli"}}},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := tt.fields.query
+			for _, filter := range tt.args.filters {
+				got = got.setFilter(filter)
+			}
+			for _, wantFilter := range tt.want.Filters {
+				found := false
+				for _, gotFilter := range got.Filters {
+					if gotFilter.field == wantFilter.field {
+						found = true
+						if !reflect.DeepEqual(wantFilter, gotFilter) {
+							t.Errorf("filter not as expected: want: %v got %v", wantFilter, gotFilter)
+						}
+					}
+				}
+				if !found {
+					t.Errorf("filter field %v not found", wantFilter.field)
+				}
+			}
+		})
+	}
+}

internal/eventstore/models/version.go

@@ -0,0 +1,22 @@
+package models
+
+import (
+	"regexp"
+
+	"github.com/caos/zitadel/internal/errors"
+)
+
+var versionRegexp = regexp.MustCompile(`^v[0-9]+(\.[0-9]+){0,2}$`)
+
+type Version string
+
+func (v Version) Validate() error {
+	if !versionRegexp.MatchString(string(v)) {
+		return errors.ThrowPreconditionFailed(nil, "MODEL-luDuS", "version is not semver")
+	}
+	return nil
+}
+
+func (v Version) String() string {
+	return string(v)
+}

internal/eventstore/models/version_test.go

@@ -0,0 +1,39 @@
+package models
+
+import "testing"
+
+func TestVersion_Validate(t *testing.T) {
+	tests := []struct {
+		name    string
+		v       Version
+		wantErr bool
+	}{
+		{
+			"correct version",
+			"v1.23.23",
+			false,
+		},
+		{
+			"no v prefix",
+			"1.2.2",
+			true,
+		},
+		{
+			"letters in version",
+			"v1.as.3",
+			true,
+		},
+		{
+			"no version",
+			"",
+			true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := tt.v.Validate(); (err != nil) != tt.wantErr {
+				t.Errorf("Version.Validate() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}