102 lines
4.2 KiB
Go
102 lines
4.2 KiB
Go
package g8
|
|
|
|
import (
|
|
"time"
|
|
|
|
"github.com/TwiN/gocache/v2"
|
|
)
|
|
|
|
// ClientProvider has the task of retrieving a Client from an external source (e.g. a database) when provided with a
|
|
// token. It should be used when you have a lot of tokens, and it wouldn't make sense to register all of them using
|
|
// AuthorizationService's WithToken, WithTokens, WithClient or WithClients.
|
|
//
|
|
// Note that the provider is used as a fallback source. As such, if a token is explicitly registered using one of the 4
|
|
// aforementioned functions, the client provider will not be used by the AuthorizationService when a request is made
|
|
// with said token. It will, however, be called upon if a token that is not explicitly registered in
|
|
// AuthorizationService is sent alongside a request going through the Gate.
|
|
//
|
|
// clientProvider := g8.NewClientProvider(func(token string) *g8.Client {
|
|
// // We'll assume that the following function calls your database and returns a struct "User" that
|
|
// // has the user's token as well as the permissions granted to said user
|
|
// user := database.GetUserByToken(token)
|
|
// if user != nil {
|
|
// return g8.NewClient(user.Token).WithPermissions(user.Permissions)
|
|
// }
|
|
// return nil
|
|
// })
|
|
// gate := g8.New().WithAuthorizationService(g8.NewAuthorizationService().WithClientProvider(clientProvider))
|
|
type ClientProvider struct {
|
|
getClientByTokenFunc func(token string) *Client
|
|
|
|
cache Cache
|
|
}
|
|
|
|
// NewClientProvider creates a ClientProvider
|
|
// The parameter that must be passed is a function that the provider will use to retrieve a client by a given token
|
|
//
|
|
// Example:
|
|
//
|
|
// clientProvider := g8.NewClientProvider(func(token string) *g8.Client {
|
|
// // We'll assume that the following function calls your database and returns a struct "User" that
|
|
// // has the user's token as well as the permissions granted to said user
|
|
// user := database.GetUserByToken(token)
|
|
// if user == nil {
|
|
// return nil
|
|
// }
|
|
// return g8.NewClient(user.Token).WithPermissions(user.Permissions)
|
|
// })
|
|
// gate := g8.New().WithAuthorizationService(g8.NewAuthorizationService().WithClientProvider(clientProvider))
|
|
func NewClientProvider(getClientByTokenFunc func(token string) *Client) *ClientProvider {
|
|
return &ClientProvider{
|
|
getClientByTokenFunc: getClientByTokenFunc,
|
|
}
|
|
}
|
|
|
|
// WithCache enables an in-memory cache for the ClientProvider.
|
|
//
|
|
// Example:
|
|
//
|
|
// clientProvider := g8.NewClientProvider(func(token string) *g8.Client {
|
|
// // We'll assume that the following function calls your database and returns a struct "User" that
|
|
// // has the user's token as well as the permissions granted to said user
|
|
// user := database.GetUserByToken(token)
|
|
// if user != nil {
|
|
// return g8.NewClient(user.Token).WithPermissions(user.Permissions)
|
|
// }
|
|
// return nil
|
|
// })
|
|
// gate := g8.New().WithAuthorizationService(g8.NewAuthorizationService().WithClientProvider(clientProvider.WithCache(time.Hour, 70000)))
|
|
func (provider *ClientProvider) WithCache(ttl time.Duration, maxSize int) *ClientProvider {
|
|
return provider.WithCustomCache(
|
|
gocache.NewCache().WithEvictionPolicy(gocache.LeastRecentlyUsed).WithMaxSize(maxSize).WithDefaultTTL(ttl),
|
|
)
|
|
}
|
|
|
|
// WithCustomCache allows you to use a custom cache implementation instead of the default one.
|
|
// By default, using WithCache will leverage gocache.
|
|
//
|
|
// Note that the custom cache must implement the Cache interface
|
|
func (provider *ClientProvider) WithCustomCache(cache Cache) *ClientProvider {
|
|
provider.cache = cache
|
|
return provider
|
|
}
|
|
|
|
// GetClientByToken retrieves a client by its token through the provided getClientByTokenFunc.
|
|
func (provider *ClientProvider) GetClientByToken(token string) *Client {
|
|
if provider.cache == nil {
|
|
return provider.getClientByTokenFunc(token)
|
|
}
|
|
if cachedClient, exists := provider.cache.Get(token); exists {
|
|
if cachedClient == nil {
|
|
return nil
|
|
}
|
|
// Safely typecast the client.
|
|
// Regardless of whether the typecast is successful or not, we return client since it'll be either client or
|
|
// nil. Technically, it should never be nil, but it's better to be safe than sorry.
|
|
client, _ := cachedClient.(*Client)
|
|
return client
|
|
}
|
|
client := provider.getClientByTokenFunc(token)
|
|
provider.cache.Set(token, client)
|
|
return client
|
|
}
|