README
¶
Mnemo
Check out the documentation here: https://pkg.go.dev/github.com/kitkitchen/mnemo
Documentation
¶
Overview ¶
Package mnemo provides a simple and robust way to generate and manage caches for any data type.
Example ¶
// Create some keys for stores, caches, and commands
var (
ExampleStoreKey StoreKey = "example_store"
ExampleCacheKey CacheKey = "example_cache"
ExampleCmdKey CommandKey = "example_cmd"
)
m := New()
// Add optional configuration for one server per instance
// Instances do not require a server to access stores, caches, or commands
// However, a server is required to access the Mnemo API with a client
m.WithServer("example", WithPattern("/example"), WithPort(8080))
// Create a new store
store, _ := NewStore(ExampleStoreKey)
// Add commands to the store
cmd := store.Commands()
cmd.Assign(map[CommandKey]func(){
ExampleCmdKey: func() {
fmt.Println("I'm a command!")
},
})
// Create a type to cache
type Message struct {
Msg string
}
// Create a new cache for messages
cache, _ := NewCache[Message](ExampleStoreKey, ExampleCacheKey)
// Cache a message
cache.Cache(ExampleCacheKey, &Message{Msg: "Hello, Mnemo!"})
// Set a reducer for the cache
// A reducer is a function that takes the current state of the cache and returns a mutation
// The mutation is then cached and sent to the reducer's feed channel
cache.SetReducer(func(state Message) (mutation any) {
return state.Msg + " With a reducer!"
})
// The integrity of the original cache is maintained and stored by it's creation time
_ = cache.RawHistory()
// Add store(s) by key
// This can be done at any time, however, it is recommended to do so before attempting to access the store
// Unique stores may only be added to one instance of Mnemo, although you may have multiple instances
m.WithStores(ExampleStoreKey)
// Access stores or caches by key from anywhere in the application
myStore, _ := UseStore(ExampleStoreKey)
// Access and execute commands from anywhere
myCmds := myStore.Commands()
myCmds.Execute(ExampleCmdKey)
// List commands if needed
_ = myCmds.List()
// Access caches from anywhere
myCache, _ := UseCache[Message](ExampleStoreKey, ExampleCacheKey)
// Access data from the cache
item, _ := myCache.Get(ExampleCacheKey)
fmt.Println(item.Data.Msg)
// Update the cache
myCache.Update(ExampleCacheKey, Message{Msg: "Hello, Mnemo! With an update!"})
// Server is a wrapper around http.Server and is non-blocking
m.Server().ListenAndServe()
Output: I'm a command! Hello, Mnemo! With a reducer!
Index ¶
- func NewCache[Cache any](s StoreKey, c CacheKey) (*cache[Cache], error)
- func NewCacheTimeoutConfig[T any](data *T, key interface{}, timeoutFun func(data *T), timeout time.Duration) cacheTimeoutConfig[T]
- func UseCache[Cache any](s StoreKey, c CacheKey) (*cache[Cache], error)
- type CacheKey
- type CommandKey
- type Commands
- type Conn
- type Error
- type Item
- type LogLevel
- type Logger
- type Mnemo
- type Opt
- type Pool
- type ReducerFunc
- type Server
- type Store
- type StoreKey
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func NewCache ¶
NewCache creates a new cache or returns an error if a cache with the same key already exists.
func NewCacheTimeoutConfig ¶
func NewCacheTimeoutConfig[T any]( data *T, key interface{}, timeoutFun func(data *T), timeout time.Duration, ) cacheTimeoutConfig[T]
NewCacheTimeoutConfig creates a new cacheTimeoutConfig. TODO: Convert to option
Types ¶
type Commands ¶
type Commands struct {
// contains filtered or unexported fields
}
Commands is a collection of commands.
func (*Commands) Assign ¶
func (c *Commands) Assign(cmds map[CommandKey]func())
Assign assigns a map of commands to the collection.
func (*Commands) Execute ¶
func (c *Commands) Execute(key CommandKey) error
Execute executes a command and returns an error if the command does not exist.
func (*Commands) List ¶
func (c *Commands) List() map[CommandKey]func()
type Conn ¶
type Conn struct {
Pool *Pool
Key interface{}
Messages chan interface{}
// contains filtered or unexported fields
}
Conn is a websocket connection with a unique key, a pointer to a pool, and a channel for messages.
func NewConn ¶
NewConn upgrades an http connection to a websocket connection and returns a Conn or an error if the upgrade fails.
func (*Conn) Close ¶
Close closes the websocket connection and removes the Conn from the pool. It returns an error if the Conn is nil.
type Error ¶
type Error[T any] struct { Err error Status int Logger Logger // contains filtered or unexported fields }
Error is a generic error type for the Mnemo package.
func IsErrorType ¶
IsErrorType reflects Error[T] from an error.
func (Error[T]) IsStatusError ¶
IsStatusError returns true if the error has a status code.
func (Error[T]) WithLogLevel ¶
WithLogLevel sets the log level for the error.
func (Error[T]) WithStatus ¶
WithStatus sets the status code for the error.
type Mnemo ¶
type Mnemo struct {
// contains filtered or unexported fields
}
Mnemo is the main struct for the Mnemo package.
func (*Mnemo) DetachStore ¶
func (*Mnemo) UseStore ¶
UseStore returns a store from the Mnemo instance.
Returns an error if the store does not exist or does not belong to the Mnemo instance.
func (*Mnemo) WithServer ¶
WithServer creates a server for the Mnemo instance.
func (*Mnemo) WithStores ¶
WithStore adds one or more stores to the Mnemo instance.
type Opt ¶
type Opt[T any] func(t *T)
func WithPattern ¶
WithPattern sets the pattern for the server's http handler.
type Pool ¶
type Pool struct {
// contains filtered or unexported fields
}
Pool is a collection of Conns
type ReducerFunc ¶
ReducerFunc is a function that takes a cache and returns a reduced version of it.
It is run against the raw cache on every change and must return json serializable data.
type Server ¶
Server is a websocket server that manages connections and messages.
func NewServer ¶
NewServer creates a new server.
The server's key must be unique. If a server with the same key already exists, an error is returned.
func (*Server) HandleSubscribe ¶
func (s *Server) HandleSubscribe(w http.ResponseWriter, r *http.Request)
HandleSubscribe upgrades the http connection to a websocket connection and adds the connection to the connection pool.
func (*Server) ListenAndServe ¶
func (s *Server) ListenAndServe()
ListenAndServe starts the server in a go routine
func (*Server) Publish ¶
func (s *Server) Publish(msg interface{})
Publish publishes a message to all connections in the connection pool.
func (*Server) SetOnNewConnection ¶
SetOnNewConnection sets a user defined call back function when a new connection is established.
Mnemo must be initialized with a server before calling this method.
type Store ¶
type Store struct {
// contains filtered or unexported fields
}
Store is a collection of caches.
func NewStore ¶
NewStore creates a new store or returns an error if a store with the same key already exists.
Source Files
Directories