goext

type Context map[string]interface{}

type CustomEvent string

type DbOptions struct {
	RetryTxCount    int
	RetryTxInterval time.Duration
}

type Error struct {
	Err    error
	Status int
	Origin string
}

type Event struct {
	Action   string
	Key      string
	Data     map[string]interface{}
	Revision int64
}

type Filter map[string]interface{}

type Handler func(context Context, environment IEnvironment) *Error

type Header map[string][]string

type IAuth interface {
	// HasRole reports whether context has given role
	HasRole(context Context, role string) bool
	// GetTenantName return name from the given context
	GetTenantName(context Context) string
	// IsAdmin reports whether context belongs to admin
	IsAdmin(context Context) bool
}

type IConfig interface {
	// Config gets a parameter from config
	Config(key string, defaultValue interface{}) interface{}
}

type ICore interface {
	// TriggerEvent causes the given event to be handled in all environments (across different-language extensions)
	TriggerEvent(event string, context Context) error
	// HandleEvent Causes the given event to be handled within the same environment
	HandleEvent(event string, context Context) error

	// RegisterEventHandler registers a global handler
	RegisterEventHandler(event string, handler Handler, priority int)
	// RegisterSchemaEventHandler registers a schema handler
	RegisterSchemaEventHandler(schemaID SchemaID, event string, schemaHandler SchemaHandler, priority int)
}

type IDatabase interface {
	// Begin starts a new transaction
	Begin() (ITransaction, error)
	// BeginTx starts a new transaction with options
	BeginTx(context Context, options *TxOptions) (ITransaction, error)

	// Options return database options from the configuration file
	Options() DbOptions

	// Within calls a function in a scoped transaction
	Within(context Context, fn func(tx ITransaction) error) error
	// WithinTx calls a function in a scoped transaction with options
	WithinTx(context Context, options *TxOptions, fn func(tx ITransaction) error) error
}

type IEnvironment interface {

	// Config returns an implementation of IConfig interface
	Config() IConfig
	// Core returns an implementation of ICore interface
	Core() ICore
	// Logger returns an implementation of ILogger interface
	Logger() ILogger
	// Schemas returns an implementation of ISchemas interface
	Schemas() ISchemas
	// Sync returns an implementation of ISync interface
	Sync() ISync
	// Database returns an implementation of IIDatabase interface
	Database() IDatabase
	// HTTP returns an implementation of IIHTTP interface
	HTTP() IHTTP
	// Auth returns an implementation of IIAuth interface
	Auth() IAuth
	// Util returns an implementation of IIUtil interface
	Util() IUtil

	// Reset clears the environment to its initial state
	Reset()
}

type IHTTP interface {
	// Request performs http request
	Request(ctx context.Context, method, rawURL string, headers map[string]interface{}, postData interface{}, opaque bool) (*Response, error)
	// RequestRaw performs raw http request
	RequestRaw(ctx context.Context, method, rawURL string, headers map[string]string, rawData string) (*Response, error)
}

type ILogger interface {
	// Critical emits a critical log message
	Critical(format string)
	// Criticalf emits a formatted critical log message
	Criticalf(format string, args ...interface{})
	// Error emits an error log message
	Error(format string)
	// Errorf emits a formatted error log message
	Errorf(format string, args ...interface{})
	// Warning emits a warning log message
	Warning(format string)
	// Warningf emits a formatted warning log message
	Warningf(format string, args ...interface{})
	// Notice emits a notice log message
	Notice(format string)
	// Noticef emits a formatted notice log message
	Noticef(format string, args ...interface{})
	// Info emits an info log message
	Info(format string)
	// Infof emits a formatted info log message
	Infof(format string, args ...interface{})
	// Debug emits a debug log message
	Debug(format string)
	// Debugf emits a formatted debug log message
	Debugf(format string, args ...interface{})
}

type IResourceBase interface {
	// Environment returns an implementation of IEnvironment interface
	Environment() IEnvironment
	// Schema returns an implementation of ISchema interface
	Schema() ISchema
	// Logger returns an implementation of ILogger interface
	Logger() ILogger
}

type ISchema interface {
	// ID returns the identifier of this resource
	ID() SchemaID

	// List returns a list of pointers to resources derived from BaseResource
	List(filter Filter, paginator *Paginator, context Context) ([]interface{}, error)

	// ListRaw returns a list of pointers to raw resources, containing db annotations
	ListRaw(filter Filter, paginator *Paginator, context Context) ([]interface{}, error)

	// LockList returns a list of pointers to locked resources derived from BaseResource
	LockList(filter Filter, paginator *Paginator, context Context, lockPolicy LockPolicy) ([]interface{}, error)

	// LockListRaw returns a list of pointers to locked raw resources, containing db annotations
	LockListRaw(filter Filter, paginator *Paginator, context Context, lockPolicy LockPolicy) ([]interface{}, error)

	// Count returns number of resources matching the filter
	Count(filter Filter, context Context) (uint64, error)

	// Fetch returns a pointer to resource derived from BaseResource
	Fetch(id string, context Context) (interface{}, error)

	// FetchRaw returns a pointer to raw resource, containing db annotations
	FetchRaw(id string, context Context) (interface{}, error)

	// FetchFilter returns a pointer to resource derived from BaseResource
	FetchFilter(filter Filter, context Context) (interface{}, error)

	// FetchFilterRaw returns a pointer to raw resource, containing db annotations
	FetchFilterRaw(filter Filter, context Context) (interface{}, error)

	// StateFetchRaw returns a resource state
	StateFetchRaw(id string, requestContext Context) (ResourceState, error)

	// LockFetch returns a pointer to locked resource derived from BaseResource, containing db annotations
	LockFetch(id string, context Context, lockPolicy LockPolicy) (interface{}, error)

	// LockFetchRaw returns a pointer to locked raw resource, containing db annotations
	LockFetchRaw(id string, context Context, lockPolicy LockPolicy) (interface{}, error)

	// LockFetchFilter returns a pointer to locked resource derived from BaseResource, containing db annotations
	LockFetchFilter(filter Filter, context Context, lockPolicy LockPolicy) (interface{}, error)

	// LockFetchFilterRaw returns a pointer to locked raw resource, containing db annotations
	LockFetchFilterRaw(filter Filter, context Context, lockPolicy LockPolicy) (interface{}, error)

	// CreateRaw creates a raw resource, given by a pointer
	CreateRaw(rawResource interface{}, context Context) error

	// DbCreateRaw creates a raw resource, given by a pointer, no events are emitted
	DbCreateRaw(rawResource interface{}, context Context) error

	// UpdateRaw updates a raw resource, given by a pointer
	UpdateRaw(rawResource interface{}, context Context) error

	// DbUpdateRaw updates a raw resource, given by a pointer, no events are emitted
	DbUpdateRaw(rawResource interface{}, context Context) error

	// DbStateUpdateRaw updates state of a raw resource
	DbStateUpdateRaw(rawResource interface{}, context Context, state *ResourceState) error

	// DeleteRaw deletes a raw resource, given by id
	DeleteRaw(id string, context Context) error

	// DbDeleteRaw deletes a raw resource, given by id, no events are emitted
	DbDeleteRaw(id string, context Context) error

	// DeleteFilterRaw deletes a raw resource, given by a filter
	DeleteFilterRaw(filter Filter, context Context) error

	// DbDeleteFilterRaw deletes a raw resource, given by a filter, no events are emitted
	DbDeleteFilterRaw(filter Filter, context Context) error

	// RegisterResourceEventHandler registers an event handler with resource for a named event with given priority
	RegisterResourceEventHandler(event ResourceEvent, schemaHandler SchemaHandler, priority int)

	// RegisterCustomEventHandler registers an event handler without resource for a custom event with given priority
	RegisterCustomEventHandler(event CustomEvent, handler Handler, priority int)

	// RegisterType registers a resource type, derived from IResourceBase
	//
	// Deprecated: use RegisterTypes instead
	RegisterType(resourceType IResourceBase)

	// RegisterRawType registers a raw resource type, containing db annotations
	//
	// Deprecated: use RegisterTypes instead
	RegisterRawType(rawResourceType interface{})

	// RegisterTypes registers both resource types derived from IResourceBase and raw containing db annotations
	RegisterTypes(rawResourceType interface{}, resourceType IResourceBase)

	// ResourceFromMap converts mapped representation to structure representation of the raw resource registered for schema
	ResourceFromMap(context map[string]interface{}) (Resource, error)

	RawSchema() interface{}

	// DerivedSchemas returns list of schemas that extend schema with given id
	DerivedSchemas() []ISchema

	// ColumnNames generates an array that has Gohan style column names
	ColumnNames() []string

	// Properties returns properties of schema
	Properties() []Property

	// Extends return list of schema_ids which given schema extends
	Extends() []SchemaID
}

type ISchemas interface {
	// List returns a list of loaded schemas
	List() []ISchema
	// Find returns a schema by id or nil if not found
	Find(id SchemaID) ISchema

	// Relations returns list of information about schema relations
	Relations(id SchemaID) []SchemaRelationInfo
}

type ISync interface {
	// Fetch fetches a path from sync
	Fetch(path string) (*Node, error)
	// Delete deletes a path from sync
	Delete(path string, prefix bool) error
	// Watch watches a single path in sync
	Watch(ctx context.Context, path string, timeout time.Duration, revision int64) ([]*Event, error)
	// Update updates a path with given json
	Update(path string, json string) error
}

type ITransaction interface {
	// Create creates a new resource
	Create(ctx context.Context, schema ISchema, resource map[string]interface{}) error
	// Update updates an existing resource
	Update(ctx context.Context, schema ISchema, resource map[string]interface{}) error
	// StateUpdate updates state of an existing resource
	StateUpdate(ctx context.Context, schema ISchema, resource map[string]interface{}, state *ResourceState) error
	// Delete deletes an existing resource
	Delete(ctx context.Context, schema ISchema, resourceID interface{}) error
	// Fetch fetches an existing resource
	Fetch(ctx context.Context, schema ISchema, filter Filter) (map[string]interface{}, error)
	// LockFetch locks and fetches an existing resource
	LockFetch(ctx context.Context, schema ISchema, filter Filter, lockPolicy LockPolicy) (map[string]interface{}, error)
	// StateFetch fetches the state of an existing resource
	StateFetch(ctx context.Context, schema ISchema, filter Filter) (ResourceState, error)
	// List lists existing resources
	List(ctx context.Context, schema ISchema, filter Filter, listOptions *ListOptions, paginator *Paginator) ([]map[string]interface{}, uint64, error)
	// LockList locks and lists existing resources
	LockList(ctx context.Context, schema ISchema, filter Filter, listOptions *ListOptions, paginator *Paginator, lockPolicy LockPolicy) ([]map[string]interface{}, uint64, error)
	// Count returns number of resources matching the filter
	Count(ctx context.Context, schema ISchema, filter Filter) (uint64, error)
	// RawTransaction returns the raw transaction
	RawTransaction() interface{} // *sqlx.Tx
	// Query executes a query
	Query(ctx context.Context, schema ISchema, query string, args []interface{}) (list []map[string]interface{}, err error)
	// Commit performs a commit of the transaction
	Commit() error
	// Exec performs an exec in transaction
	Exec(ctx context.Context, query string, args ...interface{}) error
	// Close closes the transaction
	Close() error
	// Closed return whether the transaction is closed
	Closed() bool
	// GetIsolationLevel returns the isolation level of the transaction
	GetIsolationLevel() Type
}

type IUtil interface {
	// NewUUID create a new unique ID
	NewUUID() string
	// GetTransaction returns transaction from given context
	GetTransaction(context Context) (ITransaction, bool)

	// ResourceFromMapForType converts mapped representation to structure representation of the resource for given type
	ResourceFromMapForType(context map[string]interface{}, rawResource interface{}) (Resource, error)

	// ResourceToMap converts structure representation of the resource to mapped representation
	ResourceToMap(resource interface{}) map[string]interface{}
}

type Level int

type ListOptions struct {
	// Details specifies if all the underlying structures should be
	// returned.
	Details bool
	// Fields limits list output to only showing selected fields.
	Fields []string
}

type LockPolicy int

type Maybe struct {
	MaybeState MaybeState
}

type MaybeBool struct {
	Maybe
	// contains filtered or unexported fields
}

type MaybeFloat struct {
	Maybe
	// contains filtered or unexported fields
}

type MaybeInt struct {
	Maybe
	// contains filtered or unexported fields
}

type MaybeState int

type MaybeString struct {
	Maybe
	// contains filtered or unexported fields
}

type MockIAuth struct {
	// contains filtered or unexported fields
}

type MockIAuthMockRecorder struct {
	// contains filtered or unexported fields
}

type MockIConfig struct {
	// contains filtered or unexported fields
}

type MockIConfigMockRecorder struct {
	// contains filtered or unexported fields
}

type MockICore struct {
	// contains filtered or unexported fields
}

type MockICoreMockRecorder struct {
	// contains filtered or unexported fields
}

type MockIDatabase struct {
	// contains filtered or unexported fields
}

type MockIDatabaseMockRecorder struct {
	// contains filtered or unexported fields
}

type MockIEnvironment interface {
	IEnvironment
	SetMockModules(modules MockModules)
	GetController() *gomock.Controller
	MockCore() *MockICore
	MockLogger() *MockILogger
	MockSchemas() *MockISchemas
	MockSync() *MockISync
	MockDatabase() *MockIDatabase
	MockHttp() *MockIHTTP
	MockAuth() *MockIAuth
	MockConfig() *MockIConfig
	MockUtil() *MockIUtil
}

type MockIHTTP struct {
	// contains filtered or unexported fields
}

type MockIHTTPMockRecorder struct {
	// contains filtered or unexported fields
}

type MockILogger struct {
	// contains filtered or unexported fields
}

type MockILoggerMockRecorder struct {
	// contains filtered or unexported fields
}

type MockISchemas struct {
	// contains filtered or unexported fields
}

type MockISchemasMockRecorder struct {
	// contains filtered or unexported fields
}

type MockISync struct {
	// contains filtered or unexported fields
}

type MockISyncMockRecorder struct {
	// contains filtered or unexported fields
}

type MockITransaction struct {
	// contains filtered or unexported fields
}

type MockITransactionMockRecorder struct {
	// contains filtered or unexported fields
}

type MockIUtil struct {
	// contains filtered or unexported fields
}

type MockIUtilMockRecorder struct {
	// contains filtered or unexported fields
}

type MockModules struct {
	Core, Logger, Schemas, Sync, Database, Http, Auth, Util, Config, DefaultDatabase bool
}

type Node struct {
	Key      string
	Value    string
	Revision int64
	Children []*Node
}

type OptionPaginator func(*Paginator)

type Paginator struct {
	Key    string
	Order  string
	Limit  uint64
	Offset uint64
}

type Property struct {
	ID       string
	Title    string
	Relation SchemaID
	Type     string
}

type Resource interface{}

type ResourceBase struct {
	// contains filtered or unexported fields
}

type ResourceEvent string

type ResourceState struct {
	ConfigVersion int64
	StateVersion  int64
	Error         string
	State         string
	Monitoring    string
}

type Resources []Resource

type Response struct {
	Code   int
	Status string
	Header Header
	Body   string
}

type SchemaHandler func(context Context, resource Resource, environment IEnvironment) *Error

type SchemaID string

type SchemaRelationInfo struct {
	// SchemaID relation to which schema
	SchemaID SchemaID
	// PropertyID ID of property which relation is referenced
	PropertyID string
	// OnDeleteCascade whether cascading delete on related resource delete is enabled
	OnDeleteCascade bool
}

type TxOptions struct {
	IsolationLevel Type
}

type Type string