graphvent

type ACLExt struct {
	Policies map[PolicyType]Policy
}

type ACLExtContext struct {
	Types map[PolicyType]PolicyInfo
}

type ACLInfo struct {
	Node      *Node
	Resources []string
}

type ACLMap map[NodeID]ACLInfo

type Actions []SignalType

type AllNodesPolicy struct {
	Actions Actions
}

type AllNodesPolicyJSON struct {
	Actions Actions `json:"actions"`
}

type AuthReqJSON struct {
	Time       time.Time `json:"time"`
	Pubkey     []byte    `json:"pubkey"`
	ECDHPubkey []byte    `json:"ecdh_client"`
	Signature  []byte    `json:"signature"`
}

type AuthRespJSON struct {
	Granted    time.Time `json:"granted"`
	ECDHPubkey []byte    `json:"echd_server"`
	Signature  []byte    `json:"signature"`
}

type BaseSignal struct {
	SignalDirection SignalDirection `json:"direction"`
	SignalType      SignalType      `json:"type"`
}

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

type Context struct {
	// DB is the database connection used to load and write nodes
	DB *badger.DB
	// Logging interface
	Log Logger
	// Map between database extension hashes and the registered info
	Extensions map[uint64]ExtensionInfo
	// Map between database type hashes and the registered info
	Types map[uint64]NodeInfo
	// Routing map to all the nodes local to this context
	Nodes map[NodeID]*Node
}

type ECDHExt struct {
	Granted time.Time
	Pubkey  *ecdsa.PublicKey
	Shared  []byte
}

type ECDHExtJSON struct {
	Granted time.Time `json:"granted"`
	Pubkey  []byte    `json:"pubkey"`
	Shared  []byte    `json:"shared"`
}

type ExtMap map[uint64]Extension

type ExtType string

type Extension interface {
	Serializable[ExtType]
	Process(context *Context, source NodeID, node *Node, signal Signal)
}

type ExtensionDB struct {
	Header ExtensionDBHeader
	Data   []byte
}

type ExtensionDBHeader struct {
	TypeHash uint64
	Length   uint64
}

type ExtensionInfo struct {
	Load ExtensionLoadFunc
	Type ExtType
	Data interface{}
}

type ExtensionLoadFunc func(*Context, []byte) (Extension, error)

type GQLExt struct {
	Listen             string
	Users              NodeMap
	Key                *ecdsa.PrivateKey
	ECDH               ecdh.Curve
	SubscribeLock      sync.Mutex
	SubscribeListeners []chan Signal
	// contains filtered or unexported fields
}

type GQLExtContext struct {
	// Generated GQL schema
	Schema graphql.Schema

	// Custom graphql types, mapped to NodeTypes
	NodeTypes  map[NodeType]*graphql.Object
	Interfaces []*GQLInterface

	// Schema parameters
	Types        []graphql.Type
	Query        *graphql.Object
	Mutation     *graphql.Object
	Subscription *graphql.Object
}

type GQLExtJSON struct {
	Listen  string `json:"listen"`
	Key     []byte `json:"key"`
	ECDH    uint8  `json:"ecdh_curve"`
	TLSKey  []byte `json:"ssl_key"`
	TLSCert []byte `json:"ssl_cert"`
}

type GQLInterface struct {
	Interface  *graphql.Interface
	Default    *graphql.Object
	List       *graphql.List
	Extensions []ExtType
}

type GQLPayload struct {
	OperationName string                 `json:"operationName,omitempty"`
	Query         string                 `json:"query,omitempty"`
	Variables     map[string]interface{} `json:"variables,omitempty"`
	Extensions    map[string]interface{} `json:"extensions,omitempty"`
	Data          string                 `json:"data,omitempty"`
}

type GQLType struct {
	Type *graphql.Object
	List *graphql.List
}

type GQLUnauthorized string

type GQLWSMsg struct {
	ID      string     `json:"id,omitempty"`
	Type    string     `json:"type"`
	Payload GQLPayload `json:"payload,omitempty"`
}

type GroupExt struct {
	Members NodeMap
}

type IDSignal struct {
	BaseSignal
	ID NodeID `json:"id"`
}

type ListenerExt struct {
	Buffer int
	Chan   chan Signal
}

type LockableExt struct {
	Owner        *NodeID            `json:"owner"`
	Requirements map[NodeID]string  `json:"requirements"`
	Dependencies map[NodeID]string  `json:"dependencies"`
	LockStates   map[NodeID]string  `json:"lock_states"`
	LocksHeld    map[NodeID]*NodeID `json:"locks_held"`
}

type Logger interface {
	SetComponents(components []string) error
	// Log a formatted string
	Logf(component string, format string, items ...interface{})
	// Log a map of attributes and a format string
	Logm(component string, fields map[string]interface{}, format string, items ...interface{})
	// Log a structure to a file by marshalling and unmarshalling the json
	Logj(component string, s interface{}, format string, items ...interface{})
}

type Msg struct {
	Source NodeID
	Signal Signal
}

type Node struct {
	ID         NodeID
	Type       NodeType
	Extensions map[ExtType]Extension

	// Channel for this node to receive messages from the Context
	MsgChan chan Msg
	// Channel for this node to process delayed signals
	TimeoutChan <-chan time.Time

	Active atomic.Bool

	SignalQueue []QueuedSignal
	NextSignal  *QueuedSignal
}

type NodeActions map[NodeID]Actions

type NodeDB struct {
	Header        NodeDBHeader
	QueuedSignals []QueuedSignal
	Extensions    []ExtensionDB
}

type NodeDBHeader struct {
	Magic            uint32
	NumExtensions    uint32
	NumQueuedSignals uint32
	TypeHash         uint64
}

type NodeID uuid.UUID

type NodeInfo struct {
	Type       NodeType
	Extensions []ExtType
}

type NodeMap map[NodeID]*Node

type NodeType string

type PerNodePolicy struct {
	NodeActions NodeActions `json:"node_actions"`
}

type Policy interface {
	Serializable[PolicyType]
	Allows(principal_id NodeID, action SignalType, node *Node) error
}

type PolicyInfo struct {
	Load PolicyLoadFunc
}

type PolicyLoadFunc func(*Context, []byte) (Policy, error)

type PolicyType string

type QueuedSignal struct {
	Signal Signal
	Time   time.Time
}

type RequirementOfPolicy struct {
	AllNodesPolicy
}

type ResolveContext struct {
	Context    *Context
	GQLContext *GQLExtContext
	Server     *Node
	Ext        *GQLExt
	User       *Node
}

type Serializable[I comparable] interface {
	Type() I
	Serialize() ([]byte, error)
}

type Signal interface {
	Serializable[SignalType]
	Direction() SignalDirection
}

type SignalDirection int

type SignalType string

type Singleton[K graphql.Type] struct {
	Type K
	List *graphql.List
}

type StartChildSignal struct {
	IDSignal
	Action string `json:"action"`
}

type StateContext struct {
	// Type of the state context
	Type string
	// The wrapped graph context
	Graph *Context
	// Granted permissions in the context
	Permissions map[NodeID]ACLMap
	// Locked extensions in the context
	Locked map[NodeID]*Node

	// Context state for validation
	Started  bool
	Finished bool
}

type StateFn func(*StateContext) error

type StateSignal struct {
	BaseSignal
	State string `json:"state"`
}

type StatusSignal struct {
	IDSignal
	Status string `json:"status"`
}