libpersistence

type AddPropertiesDefinition struct {
	Entity     string
	Keys       []Property
	Properties []Property
}

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

	ValueObjects []*ValueObjectDefinition

	Queries  []*CustomRequest
	Commands []*CustomRequest

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

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

type AggregateRootInterface interface {
	CheckIDExist(*libapplication.ApplicationContext, 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 BooleanDiffInterface interface {
	Old() bool
	New() bool
}

type Collection struct {
	Aggregate AggregateInterface
	Workflow  *libapplication.ApplicationContext

	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 DatasourceClient interface {
	MigrateTables(map[*EntityDefinition]*EntityDefinition, bool) error
	// InitDB(writeInfo *libdata.ClusterInfo, readInfo *libdata.ClusterInfo) (*libdata.Cluster, error)
	// CreateTenant(*libdata.Workflow, []*libdata.ModelDefinition, *libdata.Tenant) error
	// GetTenant(*libdata.Workflow, *libdata.Tenant) (*libdata.Tenant, error)
	GetImportRepository() string
	GetScanType() string
	GetDriverName() string
	GenerateInsertBuildArgsFunc(DatasourceClient, TableInterface) string
	GenerateScanFunc(DatasourceClient, string, TableInterface) string
	Get(*EntityDefinition, *libapplication.ApplicationContext, string) (interface{}, error)
	Select(TableInterface, *libapplication.ApplicationContext, []*Filter, []string, *baserepositorypb.OptionsListQuery) (interface{}, error)
	Insert(
		TableInterface, *libapplication.ApplicationContext, []interface{},
		[]string, map[string]interface{},
		[]string,
	) (interface{}, error)
	Update(
		TableInterface, *libapplication.ApplicationContext, []*Filter, interface{},
		[]string, map[string]interface{}, []string,
	) (interface{}, error)
	Delete(TableInterface, *libapplication.ApplicationContext, []*Filter) error
	BeginTransaction(*libapplication.ApplicationContext, bool) error
	RollbackTransaction(*libapplication.ApplicationContext) error
	CommitTransaction(*libapplication.ApplicationContext) error
	// CheckIDExist(*libpersistence.EntityDefinition, *libpersistence.Workflow, string) error
	// SupportTransaction() bool
	RegisterEvents(*libapplication.ApplicationContext, interface{}, []*libapplication.Event) error
	MarkDispatchedEvent(*libapplication.ApplicationContext, *libapplication.Event) error
	GetAggregateHistory(*libapplication.ApplicationContext, *libdomain.AggregateDefinition, string) ([]*libdomain.EventHistory, error)
	GetAggregateEvents(*libapplication.ApplicationContext, *libdomain.AggregateDefinition, string) ([]*libapplication.Event, error)
}

type Definitions struct {
	Repository       string
	Prefix           string
	GitRepository    string
	DatasourceClient DatasourceClient
	CacheClient      libapplication.CacheClient
	// 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

	Indexes            []*Index
	PrimaryKey         string
	ExternalDatasource DatasourceClient
	// 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(libdomain.ApplicationContext, AggregateInterface, []*Event) error
	MarkDispatchedEvent(libdomain.ApplicationContext, *Event) error
	GetAggregateEvents(libdomain.ApplicationContext, *libdomain.AggregateDefinition, string, string) ([]*Event, error)
}

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

type Factory struct {
	Aggregate                AggregateInterface
	Workflow                 *libapplication.ApplicationContext
	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 Filter struct {
	Field    string
	JSONKey  string
	Operator interface{}
}

type FilterInterface interface{}

type FloatDiffInterface interface {
	Old() float64
	New() float64
}

type Index struct {
	DatasourceClient
	Name       string
	Properties []string
}

type IntegerDiffInterface interface {
	Old() int
	New() int
}

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

type ListQueryInterface interface {
	GetOptions() *baserepositorypb.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
	DiffTypeInterface() string
	GraphqlType() string
	GraphqlSchemaType() string
	GetReferenceName() string
	GetReference() TableInterface
	// GetReferenceDefinition() *ModelDefinition
	SetReference(TableInterface)
	GetInverseProperty() string
	GetRequired() bool
	GetPrimaryKey() bool
	GetWithEntityInDomain() bool
	// GetFieldData() *FieldData
	IsStored() bool
	IsNested() bool
	SetPosition(int)
	GetPosition() int
	IsRepeated() bool
	IsTranslatable() bool
	IsIndexed() bool
	GetReturnDetailsInTests() bool
	GetLoadedPosition() int
	GetLoadedPositionMany2one() int
	GetPositionMany2one() int
	GetExternalDatasource() DatasourceClient
}

type PropertyType string

type RepeatedProperty struct {
	Property Property
}

type RepositoryInterface interface {
	// Insert(WorkflowInterface, interface{}) ([]DomainObjectInterface, error)
	// // Select(TableInterface, WorkflowInterface, *baserepositorypb.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 *[]*baserepositorypb.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
	GetIndexes() []*Index
	GetPrimaryKey() string
	IsAggregateRoot() bool
	HasTranslatable() bool
	GetAbstract() bool
	GetNoCache() bool
	DomainPath() string
	GetExternalDatasource() DatasourceClient
}

type TextDiffInterface interface {
	Old() string
	New() string
}

type TimeDiffInterface interface {
	Old() time.Time
	New() time.Time
}

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
}