Implementations on Zestor

In-Memory Store (gomap)

Mon, 01 Jan 0001 00:00:00 +0000

import "github.com/zestor-dev/zestor/store/gomap"

The gomap package provides a high-performance in-memory implementation of the store.Store interface using Go maps with sync.RWMutex for thread safety.

Features

Zero Dependencies: Pure Go, no external packages
Maximum Speed: Direct memory access, no serialization
Thread-Safe: RWMutex for concurrent access
Full Watch Support: Real-time event notifications
Validation Hooks: Per-kind validation functions
Custom Comparison: Control when updates trigger events

Quick Start

import (
 "github.com/zestor-dev/zestor/store"
 "github.com/zestor-dev/zestor/store/gomap"
)

type User struct {
 Name string
 Email string
}

func main() {
 s := gomap.NewMemStore[User](store.StoreOptions[User]{})
 defer s.Close()

 // CRUD operations
 s.Set("users", "alice", User{Name: "Alice", Email: "alice@example.com"})
 
 user, ok, _ := s.Get("users", "alice")
 if ok {
 fmt.Println(user.Name) // Alice
 }
}

Configuration Options

Basic Store

s := gomap.NewMemStore[User](store.StoreOptions[User]{})

With Validation

Validate data before writes:

SQLite Store

Mon, 01 Jan 0001 00:00:00 +0000

import "github.com/zestor-dev/zestor/store/sqlite"

The sqlite package provides a persistent SQLite-backed implementation of store.Store using modernc.org/sqlite — a pure Go SQLite driver (no CGo required).

Features

Persistent Storage: Data survives application restarts
ACID Transactions: Full transactional support
Single File: All data in one .db file
WAL Mode: Write-Ahead Logging for better concurrency
Version Tracking: Automatic version incrementing
No-op Detection: Byte-level comparison prevents unnecessary updates
Pure Go: No CGo, cross-platform compatible

Quick Start

import (
 "github.com/zestor-dev/zestor/codec"
 "github.com/zestor-dev/zestor/store/sqlite"
)

type User struct {
 Name string `json:"name"`
 Email string `json:"email"`
}

func main() {
 s, err := sqlite.New[User](sqlite.Options{
 DSN: "file:app.db?cache=shared",
 Codec: &codec.JSON{},
 })
 if err != nil {
 log.Fatal(err)
 }
 defer s.Close()

 // Same API as gomap
 s.Set("users", "alice", User{Name: "Alice", Email: "alice@example.com"})
 
 user, ok, _ := s.Get("users", "alice")
 if ok {
 fmt.Println(user.Name) // Alice
 }
}

Configuration

Options

type Options struct {
 DSN string // SQLite connection string (required)
 Codec codec.Codec // Serialization codec (required)
 BusyTimeout time.Duration // Lock wait timeout (optional)
 DisableWAL bool // Disable WAL mode (optional)
}

DSN Examples

DSN	Description
`file:app.db`	Simple file database
`file:app.db?cache=shared`	Shared cache (recommended)
`file:app.db?mode=rwc`	Read-write-create
`file::memory:?cache=shared`	In-memory (testing)

Full Configuration

s, _ := sqlite.New[Config](sqlite.Options{
 DSN: "file:config.db?cache=shared",
 Codec: &codec.JSON{},
 BusyTimeout: 5 * time.Second, // Wait up to 5s for locks
 DisableWAL: false, // Keep WAL enabled (default)
})

Database Schema

The store automatically creates this schema on first use:

PostgreSQL Store

Mon, 01 Jan 0001 00:00:00 +0000

import "github.com/zestor-dev/zestor/store/postgres"

The postgres package provides a PostgreSQL-backed implementation of store.Store using jackc/pgx/v5 with connection pooling. Writes go to a KV table and an outbox; a trigger sends NOTIFY so a background listener can drain the outbox and fan out Watch events—so watchers on different application instances can observe the same kinds.

Features

Persistent storage with ACID transactions
Cross-process watch via LISTEN / NOTIFY and an outbox (ordered by outbox id)
Namespace / tenant id (Namespace option maps to ns_id)
Version and updated_at maintained on the KV row
No-op Set: skipped when serialized bytes are unchanged (no outbox row)

Quick start

import (
 "log"
 "time"

 "github.com/zestor-dev/zestor/codec"
 "github.com/zestor-dev/zestor/store"
 "github.com/zestor-dev/zestor/store/postgres"
)

type User struct {
 Name string `json:"name"`
 Email string `json:"email"`
}

func main() {
 s, err := postgres.New[User](postgres.Options{
 ConnString: "postgresql://user:pass@localhost:5432/mydb?sslmode=disable",
 Codec: &codec.JSON{},
 Timeout: 10 * time.Second,
 })
 if err != nil {
 log.Fatal(err)
 }
 defer s.Close()

 ch, cancel, err := s.Watch("users", store.WithInitialReplay[User]())
 if err != nil {
 log.Fatal(err)
 }
 defer cancel()

 go func() {
 for ev := range ch {
 log.Printf("%s %s\n", ev.EventType, ev.Name)
 }
 }()

 _, _ = s.Set("users", "alice", User{Name: "Alice", Email: "alice@example.com"})
}

Configuration

Options

type Options struct {
 ConnString string // PostgreSQL URL (required), e.g. postgres://...
 Codec codec.Codec // Required
 Namespace int64 // Optional; default 0 — isolates rows per tenant
 Timeout time.Duration // Per-operation timeout; default 10s
}

Connection strings

Use any DSN accepted by pgx, for example: