libdomain

type AggregateDefinition struct {
	AggregateRoot *EntityDefinition
	Children      []*EntityDefinition
	UseTenants    bool

	ValueObjects []*ValueObjectDefinition

	Queries  []*CustomRequest
	Commands []*CustomRequest

	EventStoreClient    EventStoreClient
	EventDispatchClient EventDispatchClient
	ExternalData        []*ExternalData
	// contains filtered or unexported fields
}

type AggregateInterface interface {
	Definition() *AggregateDefinition
	RepositoryInterface() RepositoryInterface
	// SetRepository(RepositoryInterface)
	AggregateRootInterface() AggregateRootInterface
	LoadExternalData(
		WorkflowInterface, string, []map[string]string,
	) error
}

type AggregateRootInterface interface {
	CheckIDExist(WorkflowInterface, string) error
}

type ArgsInterface interface {
	GetName() string
	Title() string
	ProtoType() string
	GoType() string
	GoNil() string
	GraphqlSchemaType() string
	GetReferenceName() string
	GetReference() TableInterface
	SetReference(e TableInterface)
	Type() PropertyType
	IsRepeated() bool
}

type Collection struct {
	Aggregate AggregateInterface
	Workflow  WorkflowInterface

	Update func(interface{}) ([]DomainObjectInterface, error)
	Delete func() error
	// contains filtered or unexported fields
}

type CustomRequest struct {
	Name       string
	Event      string
	OnFactory  bool
	Repository bool
	Args       []ArgsInterface
	Results    []ArgsInterface
	// contains filtered or unexported fields
}

type DBType struct {
	Type  string
	Value string
}

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

type DomainObjectInterface interface {
	GetID() string
}

type EntityCommandsDefinition struct {
	Create         *RequestConfig
	Update         *RequestConfig
	Delete         *RequestConfig
	CustomCommands []*CustomRequest
}

type EntityDefinition struct {
	Aggregate AggregateInterface

	Name            string
	Keys            []Property
	Properties      []Property
	DisableID       bool
	DisableDatetime bool
	Queries         *EntityQueriesDefinition
	Commands        *EntityCommandsDefinition
	UseOneOf        bool
	// useTenants bool
	DisableDatabaseStore bool
	SafeDelete           bool
	Abstract             bool
	NoCache              bool
	// contains filtered or unexported fields
}

type EntityQueriesDefinition struct {
	Get            *RequestConfig
	List           *RequestConfig
	GetFromEvents  *RequestConfig
	CustomCommands []*CustomRequest
}

type Event struct {
	ID          string
	Aggregate   AggregateInterface
	AggregateID string
	Name        string
	Payload     map[string]interface{}
}

type EventDispatchClient interface {
	DispatchEvent(

		event *Event) error
}

type EventStoreClient interface {
	RegisterEvents(WorkflowInterface, AggregateInterface, []*Event) error
	MarkDispatchedEvent(WorkflowInterface, *Event) error
	GetAggregateEvents(WorkflowInterface, AggregateInterface, string) ([]*Event, error)
}

type ExternalData struct {
	Aggregate AggregateInterface
	TenantID  string
	Module    string
	Data      []map[string]string
}

type Factory struct {
	Aggregate                AggregateInterface
	Workflow                 WorkflowInterface
	New                      func() DomainObjectInterface
	Scan                     func(interface{}, *Collection) ([]DomainObjectInterface, error)
	CheckExternalForeignKeys func([]DomainObjectInterface) error
	Select                   func(
		filters []FilterInterface, with []string,
		offset *uint, limit *uint, orderByArg *string,
	) ([]DomainObjectInterface, error)
	Create                  func(records interface{}) ([]DomainObjectInterface, error)
	PostCreate              func(records *Collection) error
	PostCreateSelectFilters func([]FilterInterface, []DomainObjectInterface) []FilterInterface
	Upsert                  func([]FilterInterface, interface{}, bool) (interface{}, bool, error)
}

type FactoryInterface interface {
}

type FilterInterface interface{}

type JWTClaims struct {
	*jwt.StandardClaims
	TenantID  string
	UserID    string
	UserEmail string
	Groups    []*basepb.GetByExternalIDQuery
}

type ListQueryInterface interface {
	GetOptions() *basepb.OptionsListQuery
}

type Model struct{}

type ModelInterface interface {
	// Select(
	// 	*WorkflowInterface, []*libdata.Filter,
	// 	[]string, *uint, *string, *string,
	// ) (*Collection, error)
	// Create(*WorkflowInterface, []interface{}) (*Collection, error)
	// Delete(
	// 	*WorkflowInterface, []*libdata.Filter, []string,
	// ) (*Collection, error)
	// SetStore(interface{}) error
	// SetNew(func() interface{}) error
	GetID() string
}

type OnDeleteValue string

type Property interface {
	GetName() string
	NameWithoutID() string
	Title() string
	TitleWithoutID() string
	Snake() string
	Upper() string
	Type() PropertyType
	GoType() string
	GoTypeID() string
	GoNil() string
	JSONType() string
	ProtoType() string
	ProtoTypeArg() string
	ProtoTypeOptional() string
	DBType() *DBType
	GraphqlType() string
	GraphqlSchemaType() string
	GetReferenceName() string
	GetReference() TableInterface
	// GetReferenceDefinition() *ModelDefinition
	SetReference(TableInterface)
	GetInverseProperty() string
	GetRequired() bool
	GetPrimaryKey() bool
	// GetFieldData() *FieldData
	IsStored() bool
	IsNested() bool
	SetPosition(int)
	GetPosition() int
	IsRepeated() bool
	IsTranslatable() bool
	GetReturnDetailsInTests() bool
	GetLoadedPosition() int
	GetLoadedPositionMany2one() int
	GetPositionMany2one() int
}

type PropertyType string

type RepeatedProperty struct {
	Property Property
}

type RepositoryInterface interface {
	// Insert(WorkflowInterface, interface{}) ([]DomainObjectInterface, error)
	// // Select(TableInterface, WorkflowInterface, *basepb.ListQuery) ([]DomainObjectInterface, error)
	// Update(*AggregateDefinition, WorkflowInterface, []FilterInterface, interface{}) ([]DomainObjectInterface, error)
	// Delete(*AggregateDefinition, WorkflowInterface, []FilterInterface) error
	GetCache(string) ([]byte, error)
	SetCache(string, []byte) error
	GetRecordCache(string, string) ([]byte, error)
	SetRecordCache(string, string, []byte) error
	InvalidateRecordCache(string, string)
	DefinitionInterface() interface{}
}

type RequestConfig struct {
	Groups *[]*basepb.GetByExternalIDQuery
}

type TableInterface interface {
	GetName() string
	Title() string
	Snake() string
	Upper() string
	GetType() string
	IsEntity() bool
	UseTenants() bool
	GetDisableID() bool
	GetDisableDatetime() bool
	GetDisableDatabaseStore() bool
	GetUseOneOf() bool
	StoredProperties() []Property
	NestedProperties() []Property
	GetCommands() *EntityCommandsDefinition
	GetKeys() []Property
	IsAggregateRoot() bool
	HasTranslatable() bool
	GetAbstract() bool
	GetNoCache() bool
	DomainPath() string
}

type ValueObjectDefinition struct {
	Aggregate AggregateInterface

	Name       string
	Keys       []Property
	Properties []Property
	Abstract   bool
	// contains filtered or unexported fields
}

type Workflow struct {
	Context context.Context
	// WorkflowID string
	// WorkflowStep int
	TenantID     string
	JWT          string
	JWTDecrypted *JWTClaims
	// contains filtered or unexported fields
}

type WorkflowInterface interface {
	Workflow() *Workflow
	Commit() error
}