storage

unified key-value storage for go.

keys are normalized: colons become slashes, uppercase becomes lowercase, so user:alice and USER/Alice both end up as user/alice.

you can plug in different backends through a common interface:

• memory — everything stays in ram, gone when the program exits
• fs — each key is a file on disk, metadata lives in sidecar json files
• dlht — backed by a concurrent hash map
• http — talks to a remote storage server over http

basic usage

import"codeberg.org/ungo/storage"import"codeberg.org/ungo/storage/drivers/memory"s:=storage.New(memory.New())// store and retrieve typed values (json in/out)s.SetItem(ctx,"users/1",User{Name:"alice"})varuUsers.GetItem(ctx,"users/1",&u)// or store raw bytess.SetRaw(ctx,"images/icon.png",pngBytes)data,_:=s.GetRaw(ctx,"images/icon.png")

mounts

you can mount multiple backends under key prefixes. lookups go through mounts in reverse order (last mount wins):

s:=storage.New(memory.New())s.Mount("files",fs.New("./data"))s.Mount("cache",memory.New())s.SetRaw(ctx,"files/doc.txt",content)// goes to fs drivers.SetRaw(ctx,"cache/temp.json",data)// goes to memory drivers.SetRaw(ctx,"settings.json",cfg)// goes to root memory driver

watching changes

backends that support it can notify you of changes in real time:

events,_:=s.Watch(ctx,"")fore:=rangeevents{// e.event is "update" or "remove", e.key is the changed key}

snapshot and restore

export and re-import all data for backups or migration:

snap,_:=s.Snapshot(ctx,"")fresh:=storage.New(memory.New())fresh.Hydrate(ctx,snap)

http server

the server package exposes a storage over http with rest endpoints and real-time updates via server-sent events:

s:=storage.New(memory.New())srv:=server.New(s,server.Options{})http.ListenAndServe(":8080",srv.Handler())

then use the http driver from any client:

client:=storage.New(httpdriver.New(httpdriver.Options{Base:"http://localhost:8080",}))

drivers

you can implement custom drivers using the Driver interface anyways.

see _examples/ for runnable code.