neogate

type Adapter struct {
	ID    string      // Identifier of the adapter
	Mutex *sync.Mutex // Mutex to prevent concurrent exceptions (can happen with connections, better handle this on the neogate level)

	// Functions
	OnEvent AdapterFunc
	OnError func(error)
}

type AdapterContext struct {
	Event   *Event
	Message []byte
	Adapter *Adapter
}

type AdapterFunc = func(*AdapterContext) error

type AdapterSendError struct {
	AdapterErrors map[string]error // adapterId -> error
}

type Config[T any] struct {

	// Called when a client attempts to connect(create a session). Return the session info and true if the connection is allowed.
	// MUST BE SPECIFIED.
	Handshake func(c *fiber.Ctx) (SessionInfo[T], bool)

	// Session handlers
	SessionDisconnectHandler   func(session *Session[T])
	SessionEnterNetworkHandler func(session *Session[T], data T) bool // Called after pipes adapter is registered, returns if the client should be disconnected (true = disconnect)

	// Determines the id of the event adapter for a session.
	// Returns id of user adapter based on session.GetUserId(), and if of session adapter based on session.GetSessionId()
	SessionAdapterHandler func(userId string, sessionId string) (string, string)

	// Codec middleware
	EncodingMiddleware func(session *Session[T], instance *Instance[T], message []byte) ([]byte, error)
	DecodingMiddleware func(session *Session[T], instance *Instance[T], message []byte) ([]byte, error)

	// Error handler
	ErrorHandler func(err error)
}

type Context[T any] struct {
	Session    *Session[T]
	Action     string // The action to perform
	ResponseId string
	Data       []byte
	Instance   *Instance[T]
}

type CreateAction struct {
	ID      string      // Id of the adapter
	OnEvent AdapterFunc // Function that handles events received by the adapter
	OnError func(error) // Function that handles errors encountered by the adapter
}

type Event struct {
	Name string `json:"name"`
	Data any    `json:"data"`
}

type Instance[T any] struct {
	Config Config[T]
	// contains filtered or unexported fields
}

type Message[T any] struct {
	Action string `json:"action"`
	Data   T      `json:"data"`
}

type None struct{}

type NormalResponseStruct struct {
	Success bool   `json:"success"`
	Message string `json:"message,omitempty"`
}

type Session[T any] struct {
	// contains filtered or unexported fields
}

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

type SessionInfo[T any] struct {
	UserId string // Identifier of the user

	Data T // Session data you can decide how to fill
	// contains filtered or unexported fields
}

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