interfaces

type ACLPermissionChecker interface {
	CheckPermission(ctx context.Context, userID string, permissionCode string) (role string, err error)
}

type BasicAuthValidator interface {
	ValidateBasic(ctx context.Context, username, password string) error
}

type Broker interface {
	GetConfiguration() interface{} // get broker configuration (different type for each broker)
	GetPublisher() Publisher
	GetName() types.Worker
	Health() map[string]error
	Closer
}

type Cache interface {
	Get(ctx context.Context, key string) ([]byte, error)
	GetKeys(ctx context.Context, pattern string) ([]string, error)
	GetTTL(ctx context.Context, key string) (time.Duration, error)
	Set(ctx context.Context, key string, value interface{}, expire time.Duration) error
	Exists(ctx context.Context, key string) (bool, error)
	Delete(ctx context.Context, key string) error
}

type Closer interface {
	Disconnect(ctx context.Context) error
}

type GRPCHandler interface {
	Register(server *grpc.Server, middlewareGroup *types.MiddlewareGroup)
}

type GRPCMiddleware interface {
	GRPCBasicAuth(ctx context.Context) (context.Context, error)
	GRPCBearerAuth(ctx context.Context) (context.Context, error)
	GRPCMultipleAuth(ctx context.Context) (context.Context, error)

	// GRPCPermissionACL method.
	// This middleware required TokenValidator (GRPCBearerAuth middleware must executed before) for extract userID
	// default from `Subject` field in token claim payload
	// or you can custom extract user id with `SetUserIDExtractor` option when construct middleware in configs
	GRPCPermissionACL(permissionCode string) types.MiddlewareFunc
}

type GraphQLHandler interface {
	Query() interface{}
	Mutation() interface{}
	Subscription() interface{}
}

type GraphQLMiddleware interface {
	GraphQLAuth(ctx context.Context, directive *gqltypes.Directive, input interface{}) (context.Context, error)

	// GraphQLPermissionACL method.
	// This middleware required TokenValidator (GraphQLAuth middleware with BEARER must executed before) for extract userID
	// default from `Subject` field in token claim payload
	// or you can custom extract user id with `SetUserIDExtractor` option when construct middleware in configs
	GraphQLPermissionACL(ctx context.Context, directive *gqltypes.Directive, input interface{}) (context.Context, error)
}

type HTTPMiddleware interface {
	HTTPBasicAuth(next http.Handler) http.Handler
	HTTPBearerAuth(next http.Handler) http.Handler
	HTTPMultipleAuth(next http.Handler) http.Handler
	HTTPCache(next http.Handler) http.Handler

	// HTTPPermissionACL method.
	// This middleware required TokenValidator (HTTPBearerAuth middleware must executed before) for extract userID
	// default from `Subject` field in token claim payload
	// or you can custom extract user id with `SetUserIDExtractor` option when construct middleware in configs
	HTTPPermissionACL(permissionCode string) func(http.Handler) http.Handler
}

type Locker interface {
	IsLocked(key string) bool
	HasBeenLocked(key string) bool
	Unlock(key string)
	Reset(key string)
	Lock(key string, timeout time.Duration) (unlockFunc func(), err error)
	Closer
}

type Middleware interface {
	Basic(ctx context.Context, authKey string) error
	Bearer(ctx context.Context, token string) (*candishared.TokenClaim, error)

	HTTPMiddleware
	GRPCMiddleware
	GraphQLMiddleware
}

type MongoDatabase interface {
	ReadDB() *mongo.Database
	WriteDB() *mongo.Database
	Health() map[string]error
	Closer
}

type Publisher interface {
	PublishMessage(ctx context.Context, args *candishared.PublisherArgument) (err error)
}

type RESTHandler interface {
	Mount(group *echo.Group)
}

type RSAKey interface {
	PrivateKey() *rsa.PrivateKey
	PublicKey() *rsa.PublicKey
}

type RedisPool interface {
	ReadPool() *redis.Pool
	WritePool() *redis.Pool
	Health() map[string]error
	Cache() Cache
	Closer
}

type SQLDatabase interface {
	ReadDB() *sql.DB
	WriteDB() *sql.DB
	Health() map[string]error
	Closer
}

type ServerHandler interface {
	MountHandlers(group interface{}) // why interface? cause every server is different type for grouping route handler
}

type TokenValidator interface {
	ValidateToken(ctx context.Context, token string) (*candishared.TokenClaim, error)
}

type Validator interface {
	// ValidateDocument method using jsonschema with input is json source
	ValidateDocument(reference string, document interface{}) error

	// ValidateStruct method, rules from struct tag using github.com/go-playground/validator
	ValidateStruct(data interface{}) error
}

type WorkerHandler interface {
	MountHandlers(group *types.WorkerHandlerGroup)
}