rest

type APIConfig struct {
	*ServiceConfig
	BasePath            string `json:"basePath" ,yaml:"basePath"`
	RecordingBaseFolder string
	Rest                *Rest           `json:"rest"`
	JWTConfig           *JWTConfig      `json:"jwtConfig"`
	Config              json.RawMessage `json:"config"`
	Version             string          `json:"version"`
}

type BasicResource struct {
	Body     datatypes.JSONMap `gorm:"default:'[]'; null'"`
	Metadata ResourceMetadata  `gorm:"embedded"`
	// contains filtered or unexported fields
}

type CResponseType struct {
	Status string `json:"status"`
	Type   string `json:"Type"`
}

type Command struct {
	Type     string          `json:"type"`
	Payload  json.RawMessage `json:"payload"`
	Metadata CommandMetadata `json:"metadata"`
}

type CommandConfig struct {
	Type     string
	Resource string
	Handler  CommandHandler
}

type CommandDispatcher interface {
	Dispatch(ctx context.Context, command *Command, logger Log, options *CommandOptions) (response CommandResponse, err error)
	AddSubscriber(command CommandConfig) map[string][]CommandHandler
	GetSubscribers() map[string][]CommandHandler
}

type CommandDispatcherParams struct {
	fx.In
	CommandConfigs []CommandConfig
	Logger         Log
}

type CommandDispatcherResult struct {
	fx.Out
	Dispatcher CommandDispatcher
}

type CommandHandler func(ctx context.Context, command *Command, logger Log, options *CommandOptions) (response CommandResponse, err error)

type CommandMetadata struct {
	EntityID      string
	SequenceNo    int
	EntityType    string
	Version       int64
	ExecutionDate *time.Time
	UserID        string
	AccountID     string
}

type CommandOptions struct {
	ResourceRepository *ResourceRepository
	DefaultProjection  Projection
	Projections        map[string]Projection
}

type CommandResponse struct {
	Success bool
	Message string
	Code    int
	Body    interface{}
}

type ContentType struct {
	Name   string           `json:"name"`
	Schema *openapi3.Schema `json:"fields"`
}

type ContextKey string

type Controller func(params *ControllerParams) echo.HandlerFunc

type ControllerConfig struct {
	Name       string
	Controller Controller
}

type ControllerParams struct {
	Logger             Log
	CommandDispatcher  CommandDispatcher
	ResourceRepository *ResourceRepository
	DefaultProjection  *Projection
	Projections        map[string]Projection
	Schema             *openapi3.T
	PathMap            map[string]*openapi3.PathItem
	Operation          map[string]*openapi3.Operation
	Echo               *echo.Echo
	APIConfig          *APIConfig
}

type DBConfig struct {
	Name        string `json:"name"`
	Host        string `json:"host"`
	User        string `json:"username"`
	Password    string `json:"password"`
	Port        int    `json:"port"`
	Database    string `json:"database"`
	Driver      string `json:"driver"`
	MaxOpen     int    `json:"max-open"`
	MaxIdle     int    `json:"max-idle"`
	MaxIdleTime int    `json:"max-idle-time"`
	AwsIam      bool   `json:"aws-iam"`
	AwsRegion   string `json:"aws-region"`
}

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

type EchoParam struct {
	fx.In
	Config *openapi3.T
}

type Entity interface {
	ValueObject
	GetID() string
	GetType() string
}

type Event struct {
	gorm.Model
	Type    string          `json:"type"`
	Payload json.RawMessage `json:"payload"`
	Meta    EventMeta       `json:"meta" gorm:"embedded"`
	Version int             `json:"version"`
	// contains filtered or unexported fields
}

type EventDispatcher interface {
	AddSubscriber(handler EventHandlerConfig) error
	GetSubscribers(resourceType string) map[string][]EventHandler
	Dispatch(ctx context.Context, logger Log, event *Event) []error
}

type EventHandler func(ctx context.Context, logger Log, event *Event) error

type EventHandlerConfig struct {
	ResourceType string
	Type         string
	Handler      EventHandler
}

type EventMeta struct {
	ResourceID    string `json:"resourceId"`
	ResourceType  string `json:"resourceType"`
	SequenceNo    int64  `json:"sequenceNo"`
	User          string `json:"user"`
	ApplicationID string `json:"applicationId"`
	RootID        string `json:"rootId"`
	AccountID     string `json:"accountId"`
	Created       string `json:"created"`
}

type EventSourced interface {
	NewChange(event *Event)
	GetNewChanges() []Resource
	Persist()
}

type EventStore interface {
	Repository
	EventDispatcher
	Projection
}

type FilterProperties struct {
	Field    string        `json:"field"`
	Operator string        `json:"operator"`
	Value    interface{}   `json:"value"`
	Values   []interface{} `json:"values"`
}

type GORMParams struct {
	fx.In
	Config *APIConfig
}

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

type GORMProjectionParams struct {
	fx.In
	GORMDB       *gorm.DB
	EventConfigs []EventHandlerConfig `group:"eventHandlers"`
}

type GORMProjectionResult struct {
	fx.Out
	Dispatcher        EventStore
	DefaultProjection Projection `name:"defaultProjection"`
}

type GORMResult struct {
	fx.Out
	GORMDB *gorm.DB
	SQLDB  *sql.DB
}

type GlobalInitializer func(context.Context, *openapi3.T) (context.Context, error)

type HealthCheckResponse struct {
	Version string `json:"version"`
}

type JWTConfig struct {
	Key             string                 `json:"key"`         //Signing key needed for validating token
	SigningKeys     map[string]interface{} `json:"signingKeys"` //Key map used for validating token.  Can be used in place of a single key
	Certificate     []byte                 `json:"certificate"`
	CertificatePath string                 `json:"certificatePath"` //Path the signing certificate used to validate token.  Can  be used in place of a key
	JWKSUrl         string                 `json:"jwksUrl"`         //URL to JSON Web Key set.  Can be used in place of a Key
	TokenLookup     string                 `json:"tokenLookup"`
	Claims          map[string]interface{} `json:"claims"`
	AuthScheme      string                 `json:"authScheme"`
	ContextKey      string                 `json:"contextKey"`
	SigningMethod   string                 `json:"signingMethod"`
}

type ListApiResponse struct {
	Total int64           `json:"total"`
	Page  int             `json:"page"`
	Items []BasicResource `json:"items"`
}

type Log interface {
	Debugf(format string, args ...interface{})
	Infof(format string, args ...interface{})
	Warnf(format string, args ...interface{})
	Printf(format string, args ...interface{})
	Errorf(format string, args ...interface{})
	Fatalf(format string, args ...interface{})
	Panicf(format string, args ...interface{})

	Debug(args ...interface{})
	Info(args ...interface{})
	Warn(args ...interface{})
	Print(args ...interface{})
	Error(args ...interface{})
	Fatal(args ...interface{})
	Panic(args ...interface{})
}

type LogConfig struct {
	Level        string `json:"level"`
	Name         string `json:"name"`
	ReportCaller bool   `json:"report-caller"`
	Formatter    string `json:"formatter"`
}

type LoggerResult struct {
	fx.Out
	Logger Log
}

type Middleware func(params *MiddlewareParams) echo.MiddlewareFunc

type MiddlewareConfig struct {
	Name       string
	Middleware Middleware
}

type MiddlewareParams struct {
	Logger                Log
	CommandDispatcher     CommandDispatcher
	ResourceRepository    *ResourceRepository
	Schema                *openapi3.T
	APIConfig             *APIConfig
	PathMap               map[string]*openapi3.PathItem
	Operation             map[string]*openapi3.Operation
	SecuritySchemes       map[string]Validator
	AuthorizationEnforcer *casbin.Enforcer
}

type OAuth2 struct {
	Flows *openapi3.OAuthFlows
	// contains filtered or unexported fields
}

type OpenIDConnect struct {
	KeySet oidc.KeySet
	// contains filtered or unexported fields
}

type OperationInitializer func(context.Context, string, string, *openapi3.T, *openapi3.PathItem, *openapi3.Operation) (context.Context, error)

type PathConfig struct {
	Handler        string          `json:"handler" ,yaml:"handler"`
	Group          bool            `json:"group" ,yaml:"group"`
	Middleware     []string        `json:"middleware"`
	Config         json.RawMessage `json:"config"`
	DisableCors    bool            `json:"disable-cors"`
	AllowedHeaders []string        `json:"allowed-headers" ,yaml:"allowed-headers"`
	AllowedOrigins []string        `json:"allowed-origins" ,yaml:"allowed-origins"`
}

type PathInitializer func(context.Context, string, *openapi3.T, *openapi3.PathItem) (context.Context, error)

type Projection interface {
	GetByURI(ctxt context.Context, logger Log, uri string) (Resource, error)
	// GetByKey returns a single content entity
	GetByKey(ctxt context.Context, identifiers map[string]interface{}) (Resource, error)
	// GetList returns a paginated result of content entities
	GetList(ctx context.Context, page int, limit int, query string, sortOptions map[string]string, filterOptions map[string]interface{}) ([]Resource, int64, error)
	GetByProperties(ctxt context.Context, identifiers map[string]interface{}) ([]Entity, error)
	GetEventHandlers() []EventHandlerConfig
}

type QueryProperties struct {
	Value string `json:"value"`
	Field string `json:"field"`
}

type Repository interface {
	Persist(ctxt context.Context, logger Log, resources []Resource) []error
	Remove(ctxt context.Context, logger Log, resources []Resource) []error
}

type Resource interface {
	EventSourced
	GetType() string
	GetSequenceNo() int64
	GetID() string
	FromBytes(schema *openapi3.T, data []byte) (Resource, error)
	IsValid() bool
	GetErrors() []error
}

type ResourceCreateParams struct {
	Resource Resource
	Schema   *openapi3.Schema
}

type ResourceMetadata struct {
	ID         string `gorm:"primaryKey"`
	SequenceNo int64
	Type       string
	Version    int
	UserID     string
	AccountID  string
}

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

type ResourceRepositoryParams struct {
	fx.In
	EventStore        EventStore
	Projections       []Projection `group:"projections"`
	DefaultProjection Projection   `name:"defaultProjection" optional:"true"`
	Config            *openapi3.T
}

type ResourceRepositoryResult struct {
	fx.Out
	Repository *ResourceRepository
}

type Rest struct {
	Middleware    []string `json:"x-middleware"`
	PreMiddleware []string `json:"pre-middleware"`
}

type RouteParams struct {
	fx.In
	Config                *openapi3.T
	APIConfig             *APIConfig
	Echo                  *echo.Echo
	Logger                Log
	CommandDispatcher     CommandDispatcher
	ResourceRepository    *ResourceRepository
	Controllers           []map[string]Controller `group:"controllers"`
	Middlewares           []map[string]Middleware `group:"middlewares"`
	GORMDB                *gorm.DB
	AuthorizationEnforcer *casbin.Enforcer
	SecuritySchemes       map[string]Validator
}

type SecurityConfiguration struct {
	fx.Out
	SecuritySchemes map[string]Validator
	AuthEnforcer    *casbin.Enforcer
}

type SecurityParams struct {
	fx.In
	Config     *openapi3.T
	HttpClient *http.Client
	GORMDB     *gorm.DB
}

type ServiceConfig struct {
	ModuleID      string      `json:"moduleId"`
	Title         string      `json:"title"`
	AccountID     string      `json:"accountId"`
	ApplicationID string      `json:"applicationId"`
	AccountName   string      `json:"accountName"`
	Database      *DBConfig   `json:"database"`
	Databases     []*DBConfig `json:"databases"`
	Log           *LogConfig  `json:"log"`
	BaseURL       string      `json:"baseURL"`
	LoginURL      string      `json:"loginURL"`
	GraphQLURL    string      `json:"graphQLURL"`
	SessionKey    string      `json:"sessionKey"`
	Secret        string      `json:"secret"`
	AccountURL    string      `json:"accountURL"`
}

type ValidationResult struct {
	Valid         bool
	Token         string
	UserID        string
	Role          string
	AccountID     string
	ApplicationID string
}

type Validator interface {
	Validate(ctxt echo.Context) (*ValidationResult, error)
	FromSchema(ctx context.Context, scheme *openapi3.SecurityScheme, httpClient *http.Client) (Validator, error)
}

type ValueObject interface {
	IsValid() bool
	AddError(err error)
	GetErrors() []error
}

type WeOSConfigParams struct {
	fx.In
	Config *openapi3.T
	Logger Log
}

type WeOSConfigResult struct {
	fx.Out
	Config *APIConfig
}

type Zap struct {
	*zap.SugaredLogger
	// contains filtered or unexported fields
}