chore: move the go code into a subfolder

apps/api/internal/eventstore/v1/models/event.go

@@ -0,0 +1,154 @@
+package models
+
+import (
+	"encoding/json"
+	"reflect"
+	"time"
+
+	"github.com/shopspring/decimal"
+
+	"github.com/zitadel/zitadel/internal/eventstore"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+type EventType string
+
+func (et EventType) String() string {
+	return string(et)
+}
+
+var _ eventstore.Event = (*Event)(nil)
+
+type Event struct {
+	ID               string
+	Seq              uint64
+	Pos              decimal.Decimal
+	CreationDate     time.Time
+	Typ              eventstore.EventType
+	PreviousSequence uint64
+	Data             []byte
+
+	AggregateID      string
+	AggregateType    eventstore.AggregateType
+	AggregateVersion eventstore.Version
+	Service          string
+	User             string
+	ResourceOwner    string
+	InstanceID       string
+}
+
+// Aggregate implements [eventstore.Event]
+func (e *Event) Aggregate() *eventstore.Aggregate {
+	return &eventstore.Aggregate{
+		ID:            e.AggregateID,
+		Type:          e.AggregateType,
+		ResourceOwner: e.ResourceOwner,
+		InstanceID:    e.InstanceID,
+		// Version:       eventstore.Version(e.AggregateVersion),
+	}
+}
+
+// CreatedAt implements [eventstore.Event]
+func (e *Event) CreatedAt() time.Time {
+	return e.CreationDate
+}
+
+// DataAsBytes implements [eventstore.Event]
+func (e *Event) DataAsBytes() []byte {
+	return e.Data
+}
+
+// Unmarshal implements [eventstore.Event]
+func (e *Event) Unmarshal(ptr any) error {
+	if len(e.Data) == 0 {
+		return nil
+	}
+	return json.Unmarshal(e.Data, ptr)
+}
+
+// EditorService implements [eventstore.Event]
+func (e *Event) EditorService() string {
+	return e.Service
+}
+
+// Creator implements [eventstore.action]
+func (e *Event) Creator() string {
+	return e.User
+}
+
+// Sequence implements [eventstore.Event]
+func (e *Event) Sequence() uint64 {
+	return e.Seq
+}
+
+// Position implements [eventstore.Event]
+func (e *Event) Position() decimal.Decimal {
+	return e.Pos
+}
+
+// Type implements [eventstore.action]
+func (e *Event) Type() eventstore.EventType {
+	return e.Typ
+}
+
+// Type implements [eventstore.action]
+func (e *Event) Revision() uint16 {
+	return 0
+}
+
+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, zerrors.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, zerrors.ThrowInvalidArgument(nil, "MODEL-rjWdN", "data is not valid")
+		}
+		bytes, err := json.Marshal(v)
+		if err != nil {
+			return nil, zerrors.ThrowInvalidArgument(err, "MODEL-Y2OpM", "unable to marshal data")
+		}
+		return bytes, nil
+	}
+}
+
+func (e *Event) Validate() error {
+	if e == nil {
+		return zerrors.ThrowPreconditionFailed(nil, "MODEL-oEAG4", "event is nil")
+	}
+	if string(e.Typ) == "" {
+		return zerrors.ThrowPreconditionFailed(nil, "MODEL-R2sB0", "type not defined")
+	}
+
+	if e.AggregateID == "" {
+		return zerrors.ThrowPreconditionFailed(nil, "MODEL-A6WwL", "aggregate id not set")
+	}
+	if e.AggregateType == "" {
+		return zerrors.ThrowPreconditionFailed(nil, "MODEL-EzdyK", "aggregate type not set")
+	}
+	if err := e.AggregateVersion.Validate(); err != nil {
+		return zerrors.ThrowPreconditionFailed(err, "MODEL-KO71q", "version invalid")
+	}
+	if e.Service == "" {
+		return zerrors.ThrowPreconditionFailed(nil, "MODEL-4Yqik", "editor service not set")
+	}
+	if e.User == "" {
+		return zerrors.ThrowPreconditionFailed(nil, "MODEL-L3NHO", "editor user not set")
+	}
+	if e.ResourceOwner == "" {
+		return zerrors.ThrowPreconditionFailed(nil, "MODEL-omFVT", "resource ow")
+	}
+	return nil
+}

apps/api/internal/eventstore/v1/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",
+				Service:          "management",
+				User:             "hodor",
+				ResourceOwner:    "org",
+				Typ:              "born",
+			}},
+			wantErr: true,
+		},
+		{
+			name: "no aggregate type",
+			fields: fields{event: &Event{
+				AggregateID:      "hodor",
+				AggregateVersion: "v1.0.0",
+				Service:          "management",
+				User:             "hodor",
+				ResourceOwner:    "org",
+				Typ:              "born",
+			}},
+			wantErr: true,
+		},
+		{
+			name: "no aggregate version",
+			fields: fields{event: &Event{
+				AggregateID:   "hodor",
+				AggregateType: "user",
+				Service:       "management",
+				User:          "hodor",
+				ResourceOwner: "org",
+				Typ:           "born",
+			}},
+			wantErr: true,
+		},
+		{
+			name: "no editor service",
+			fields: fields{event: &Event{
+				AggregateID:      "hodor",
+				AggregateType:    "user",
+				AggregateVersion: "v1.0.0",
+				User:             "hodor",
+				ResourceOwner:    "org",
+				Typ:              "born",
+			}},
+			wantErr: true,
+		},
+		{
+			name: "no editor user",
+			fields: fields{event: &Event{
+				AggregateID:      "hodor",
+				AggregateType:    "user",
+				AggregateVersion: "v1.0.0",
+				Service:          "management",
+				ResourceOwner:    "org",
+				Typ:              "born",
+			}},
+			wantErr: true,
+		},
+		{
+			name: "no resource owner",
+			fields: fields{event: &Event{
+				AggregateID:      "hodor",
+				AggregateType:    "user",
+				AggregateVersion: "v1.0.0",
+				Service:          "management",
+				User:             "hodor",
+				Typ:              "born",
+			}},
+			wantErr: true,
+		},
+		{
+			name: "no type",
+			fields: fields{event: &Event{
+				AggregateID:      "hodor",
+				AggregateType:    "user",
+				AggregateVersion: "v1.0.0",
+				Service:          "management",
+				User:             "hodor",
+				ResourceOwner:    "org",
+			}},
+			wantErr: true,
+		},
+		{
+			name: "all fields set",
+			fields: fields{event: &Event{
+				AggregateID:      "hodor",
+				AggregateType:    "user",
+				AggregateVersion: "v1.0.0",
+				Service:          "management",
+				User:             "hodor",
+				ResourceOwner:    "org",
+				Typ:              "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)
+			}
+		})
+	}
+}

apps/api/internal/eventstore/v1/models/object.go

@@ -0,0 +1,40 @@
+package models
+
+import (
+	"time"
+
+	"github.com/zitadel/zitadel/internal/eventstore"
+)
+
+type ObjectRoot struct {
+	AggregateID   string    `json:"-"`
+	Sequence      uint64    `json:"-"`
+	ResourceOwner string    `json:"-"`
+	InstanceID    string    `json:"-"`
+	CreationDate  time.Time `json:"-"`
+	ChangeDate    time.Time `json:"-"`
+}
+
+func (o *ObjectRoot) AppendEvent(event eventstore.Event) {
+	if o.AggregateID == "" {
+		o.AggregateID = event.Aggregate().ID
+	} else if o.AggregateID != event.Aggregate().ID {
+		return
+	}
+	if o.ResourceOwner == "" {
+		o.ResourceOwner = event.Aggregate().ResourceOwner
+	}
+	if o.InstanceID == "" {
+		o.InstanceID = event.Aggregate().InstanceID
+	}
+
+	o.ChangeDate = event.CreatedAt()
+	if o.CreationDate.IsZero() {
+		o.CreationDate = o.ChangeDate
+	}
+
+	o.Sequence = event.Sequence()
+}
+func (o *ObjectRoot) IsZero() bool {
+	return o.AggregateID == ""
+}

apps/api/internal/eventstore/v1/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",
+					Seq:          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",
+					Seq:              34555425,
+					CreationDate:     time.Now(),
+					PreviousSequence: 22,
+				},
+				false,
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			o := &ObjectRoot{
+				AggregateID:  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.Seq {
+				t.Errorf("sequence not equal to event: event: %d root: %d", tt.args.event.Seq, 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)
+			}
+		})
+	}
+}