Concepts on Zestor

Store & Kinds

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

The Store Interface

Zestor’s core is the Store interface, which provides a complete set of operations for managing in-memory data:

type Store[T any] interface {
 Reader[T]
 Writer[T]
 Watcher[T]
 Close() error
 Dump() string
}

The interface is generic — you specify your data type T when creating the store, and all operations are type-safe.

Kinds: Organizing Your Data

Data in Zestor is organized by kinds. Think of kinds like tables in a database or collections in MongoDB.

Watching & Events

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

Overview

Zestor’s watch system lets you subscribe to changes in real-time. When data is created, updated, or deleted, watchers receive events through a channel.

Basic Watching

// Start watching the "users" kind
ch, cancel, err := s.Watch("users")
if err != nil {
 log.Fatal(err)
}
defer cancel() // Always cancel when done

// Process events
for event := range ch {
 fmt.Printf("%s: %s\n", event.EventType, event.Name)
}

Event Types

Three event types are emitted:

Event	When	`event.Object` contains
`EventTypeCreate`	New key is set	The new value
`EventTypeUpdate`	Existing key is modified	The new value
`EventTypeDelete`	Key is deleted	The previous value

for event := range ch {
 switch event.EventType {
 case store.EventTypeCreate:
 fmt.Printf("Created %s: %+v\n", event.Name, event.Object)
 case store.EventTypeUpdate:
 fmt.Printf("Updated %s: %+v\n", event.Name, event.Object)
 case store.EventTypeDelete:
 fmt.Printf("Deleted %s (was: %+v)\n", event.Name, event.Object)
 }
}

Event Structure

type Event[T any] struct {
 Kind string // The kind (e.g., "users")
 Name string // The key (e.g., "alice")
 EventType EventType // create, update, or delete
 Object T // The value (or previous value for delete)
}

Watch Options

Filter by Event Type

Only receive specific event types:

Interface Segregation

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

Overview

Zestor follows the Interface Segregation Principle by splitting its functionality into focused interfaces. This allows you to pass only the access level your code needs.

Available Interfaces

// Reader provides read-only access
type Reader[T any] interface {
 Get(kind, key string) (val T, ok bool, err error)
 List(kind string, filter ...FilterFunc[T]) (map[string]T, error)
 Count(kind string) (int, error)
 Keys(kind string) ([]string, error)
 Values(kind string) ([]KeyValue[T], error)
 GetAll() (map[string]map[string]T, error)
}

// Writer provides write access
type Writer[T any] interface {
 Set(kind, key string, value T) (created bool, err error)
 SetFn(kind, key string, fn func(v T) (T, error)) (changed bool, err error)
 SetAll(kind string, values map[string]T) error
 Delete(kind, key string) (existed bool, prev T, err error)
}

// Watcher provides watch access
type Watcher[T any] interface {
 Watch(kind string, opts ...WatchOption[T]) (r <-chan *Event[T], cancel func(), err error)
}

// ReadWriter combines Reader and Writer
type ReadWriter[T any] interface {
 Reader[T]
 Writer[T]
}

// Store is the full interface
type Store[T any] interface {
 Reader[T]
 Writer[T]
 Watcher[T]
 Close() error
 Dump() string
}

Why Interface Segregation?

1. Principle of Least Privilege

Pass only the access your code needs:

Codecs

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

What is a Codec?

A codec (coder/decoder) handles serialization and deserialization of your data types. Persistent stores like SQLite need codecs to convert Go structs to bytes for storage and back again when reading.

type Codec interface {
 Marshal(v any) ([]byte, error)
 Unmarshal(data []byte, v any) error
}

Why Codecs Matter

In-memory stores like gomap store your Go values directly — no serialization needed. But persistent stores must convert values to bytes:

┌──────────────┐ Marshal ┌──────────────┐
│ Go Struct │ ───────────────► │ []byte │ ───► Storage
│ {Name:"X"} │ │ [123,34...] │
└──────────────┘ └──────────────┘

┌──────────────┐ Unmarshal ┌──────────────┐
│ Go Struct │ ◄─────────────── │ []byte │ ◄─── Storage
│ {Name:"X"} │ │ [123,34...] │
└──────────────┘ └──────────────┘

Available Codecs

JSON

The most common choice. Human-readable, widely supported.