@vira-ui/cli 0.3.3-alpha → 0.4.1-alpha

package/dist/go/eventsAPI.js

@@ -0,0 +1,414 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventsAPI = void 0;
+exports.eventsAPI = `package events
+
+import (
+  "context"
+  "encoding/json"
+  "sync"
+  "time"
+
+  jsonpatch "github.com/evanphx/json-patch/v5"
+  "github.com/gorilla/websocket"
+)
+
+// VRP_VERSION is the current protocol version.
+const VRP_VERSION = "0.1"
+
+// WSMessage matches protocol message schema.
+type WSMessage struct {
+  Type      string          \`json:"type"\`
+  Name      string          \`json:"name,omitempty"\`
+  Channel   string          \`json:"channel,omitempty"\`
+  Channels  []string        \`json:"channels,omitempty"\`
+  Data      json.RawMessage \`json:"data,omitempty"\`
+  Patch     json.RawMessage \`json:"patch,omitempty"\`
+  Ts        int64           \`json:"ts,omitempty"\`
+  Client    string          \`json:"client,omitempty"\`
+  Version   string          \`json:"version,omitempty"\`
+  Auth      string          \`json:"authToken,omitempty"\`
+  Session   string          \`json:"session,omitempty"\`
+  Interval  int64           \`json:"interval,omitempty"\`
+  VersionNo int64           \`json:"versionNo,omitempty"\`
+  MsgID     string          \`json:"msgId,omitempty"\` // for idempotency
+  Code      string          \`json:"code,omitempty"\`  // error code
+  Message   string          \`json:"message,omitempty"\` // error message
+  Retry     bool            \`json:"retry,omitempty"\` // error retry flag
+}
+
+// EventHandler signature for domain events.
+type EventHandler func(ctx context.Context, hub EventEmitter, conn *websocket.Conn, msg WSMessage)
+
+// EventEmitter exposes server-side emit/update/diff for handlers.
+type EventEmitter interface {
+  Emit(channel string, payload any)
+  Update(channel string, payload any)
+  Diff(channel string, patch any)
+  Snapshot(channel string) (json.RawMessage, int64, bool)
+}
+
+// DiffMode controls how diffs are generated.
+type DiffMode int
+
+const (
+  DiffModeMerge DiffMode = iota // JSON Merge Patch (RFC 7396)
+  DiffModePatch                 // JSON Patch (RFC 6902)
+)
+
+// Hub is an in-memory event hub with state and versions.
+type Hub struct {
+  mu        sync.Mutex
+  clients   map[*websocket.Conn]bool
+  subs      map[string]map[*websocket.Conn]bool
+  sessions  map[*websocket.Conn]string
+  state     map[string]json.RawMessage
+  versions  map[string]int64
+  events    map[string]EventHandler
+  diffMode  DiffMode
+  history   map[string][]StateSnapshot // for replay
+  maxHistory int
+  store     StateStore
+  ttlSec    int
+}
+
+// StateSnapshot stores a versioned state snapshot.
+type StateSnapshot struct {
+  Data      json.RawMessage
+  VersionNo int64
+  Ts        int64
+}
+
+func NewHub() *Hub {
+  return &Hub{
+    clients:   make(map[*websocket.Conn]bool),
+    subs:      make(map[string]map[*websocket.Conn]bool),
+    sessions:  make(map[*websocket.Conn]string),
+    state:     make(map[string]json.RawMessage),
+    versions:  make(map[string]int64),
+    events:    make(map[string]EventHandler),
+    diffMode:  DiffModeMerge,
+    history:   make(map[string][]StateSnapshot),
+    maxHistory: 100, // keep last 100 versions per channel
+    store:     MemoryStore{},
+    ttlSec:    0,
+    msgIDs:    make(map[string]int64),
+    maxMsgIDs: 1000, // keep last 1000 msgIds for dedup
+  }
+}
+
+// SetDiffMode sets the diff generation mode.
+func (h *Hub) SetDiffMode(mode DiffMode) {
+  h.mu.Lock()
+  defer h.mu.Unlock()
+  h.diffMode = mode
+}
+
+// SetHistoryLimit limits how many snapshots are stored per channel.
+func (h *Hub) SetHistoryLimit(limit int) {
+  h.mu.Lock()
+  defer h.mu.Unlock()
+  if limit > 0 {
+    h.maxHistory = limit
+  }
+}
+
+// SetStore sets the state store (memory/redis).
+func (h *Hub) SetStore(store StateStore) {
+  h.mu.Lock()
+  defer h.mu.Unlock()
+  if store != nil {
+    h.store = store
+  }
+}
+
+// SetTTL sets TTL for persisted entries.
+func (h *Hub) SetTTL(ttlSec int) {
+  h.mu.Lock()
+  defer h.mu.Unlock()
+  if ttlSec >= 0 {
+    h.ttlSec = ttlSec
+  }
+}
+
+// CheckMsgID returns true if msgId was already seen (and records it), false otherwise.
+// Used for idempotency: duplicate messages with same msgId are ignored.
+func (h *Hub) CheckMsgID(msgID string) bool {
+  if msgID == "" {
+    return false
+  }
+  h.mu.Lock()
+  defer h.mu.Unlock()
+  now := time.Now().UnixMilli()
+  // Clean old entries (older than 5 minutes)
+  cutoff := now - 5*60*1000
+  for id, ts := range h.msgIDs {
+    if ts < cutoff {
+      delete(h.msgIDs, id)
+    }
+  }
+  // Check if exists
+  if _, exists := h.msgIDs[msgID]; exists {
+    return true // duplicate
+  }
+  // Record
+  h.msgIDs[msgID] = now
+  // Trim if too many
+  if len(h.msgIDs) > h.maxMsgIDs {
+    // Remove oldest 100 entries
+    type entry struct {
+      id  string
+      ts  int64
+    }
+    var entries []entry
+    for id, ts := range h.msgIDs {
+      entries = append(entries, entry{id, ts})
+    }
+    // Sort by timestamp (oldest first)
+    for i := 0; i < len(entries)-1; i++ {
+      for j := i + 1; j < len(entries); j++ {
+        if entries[i].ts > entries[j].ts {
+          entries[i], entries[j] = entries[j], entries[i]
+        }
+      }
+    }
+    // Remove oldest 100
+    for i := 0; i < 100 && i < len(entries); i++ {
+      delete(h.msgIDs, entries[i].id)
+    }
+  }
+  return false // new message
+}
+
+// Emit aliases Update with force update.
+func (h *Hub) Emit(channel string, payload any) {
+  h.applyUpdate(channel, payload, true)
+}
+
+// Update applies merge-patch optimization when possible.
+func (h *Hub) Update(channel string, payload any) {
+  h.applyUpdate(channel, payload, false)
+}
+
+// Diff applies a raw patch and broadcasts.
+func (h *Hub) Diff(channel string, patch any) {
+  h.applyDiff(channel, patch)
+}
+
+func (h *Hub) Snapshot(channel string) (json.RawMessage, int64, bool) {
+  h.mu.Lock()
+  snap, ok := h.state[channel]
+  v := h.versions[channel]
+  store := h.store
+  h.mu.Unlock()
+  
+  if ok {
+    return snap, v, true
+  }
+  
+  // Try loading from store if available
+  if store != nil {
+    if snap, ok, _ := store.LoadSnapshot(context.Background(), channel); ok {
+      // Update in-memory cache
+      h.mu.Lock()
+      h.state[channel] = snap.Data
+      h.versions[channel] = snap.VersionNo
+      h.mu.Unlock()
+      return snap.Data, snap.VersionNo, true
+    }
+  }
+  
+  return nil, 0, false
+}
+
+// Replay returns state snapshots for a channel from a given version.
+func (h *Hub) Replay(channel string, fromVersion int64) []StateSnapshot {
+  h.mu.Lock()
+  hist := h.history[channel]
+  store := h.store
+  h.mu.Unlock()
+  
+  var result []StateSnapshot
+  for _, snap := range hist {
+    if snap.VersionNo > fromVersion {
+      result = append(result, snap)
+    }
+  }
+  
+  // Try loading from store if available and in-memory is empty/incomplete
+  if store != nil && len(result) == 0 {
+    if stored, err := store.LoadHistory(context.Background(), channel, fromVersion); err == nil {
+      result = stored
+    }
+  }
+  
+  return result
+}
+
+// internal helpers
+func (h *Hub) applyUpdate(channel string, payload any, force bool) {
+  newData, err := json.Marshal(payload)
+  if err != nil {
+    return
+  }
+  var prev []byte
+  h.mu.Lock()
+  if s, ok := h.state[channel]; ok {
+    prev = append([]byte{}, s...)
+  }
+  h.state[channel] = newData
+  h.versions[channel]++
+  version := h.versions[channel]
+  
+  // Save snapshot for replay
+  snap := StateSnapshot{
+    Data:      append([]byte{}, newData...),
+    VersionNo: version,
+    Ts:        time.Now().UnixMilli(),
+  }
+  hist := h.history[channel]
+  hist = append(hist, snap)
+  if len(hist) > h.maxHistory {
+    hist = hist[len(hist)-h.maxHistory:]
+  }
+  h.history[channel] = hist
+  store := h.store
+  ttl := h.ttlSec
+
+  h.mu.Unlock()
+
+  if store != nil {
+    _ = store.SaveSnapshot(context.Background(), channel, snap, ttl)
+    _ = store.AppendHistory(context.Background(), channel, snap, h.maxHistory, ttl)
+  }
+
+  if !force && prev != nil {
+    var patch json.RawMessage
+    var err error
+    if h.diffMode == DiffModePatch {
+      // Generate RFC 6902 JSON Patch
+      patchOps, err := jsonpatch.CreatePatch(prev, newData)
+      if err == nil {
+        patch, _ = json.Marshal(patchOps)
+      }
+    } else {
+      // Generate RFC 7396 JSON Merge Patch
+      patch, err = jsonpatch.CreateMergePatch(prev, newData)
+    }
+    if err == nil && len(patch) > 2 {
+      h.applyDiff(channel, patch)
+      return
+    }
+  }
+
+  msg := WSMessage{
+    Type:      "update",
+    Channel:   channel,
+    Data:      newData,
+    VersionNo: version,
+    Ts:        time.Now().UnixMilli(),
+  }
+  raw, err := json.Marshal(msg)
+  if err != nil {
+    return
+  }
+  h.broadcast(channel, raw)
+}
+
+func (h *Hub) applyDiff(channel string, patch any) {
+  data, err := json.Marshal(patch)
+  if err != nil {
+    return
+  }
+  h.mu.Lock()
+  prev := h.state[channel]
+  merged := prev
+  if prev != nil {
+    if h.diffMode == DiffModePatch {
+      // Apply RFC 6902 JSON Patch
+      ops, err := jsonpatch.DecodePatch(data)
+      if err == nil {
+        applied, err := ops.Apply(prev)
+        if err == nil {
+          merged = applied
+        }
+      }
+    } else {
+      // Apply RFC 7396 JSON Merge Patch
+      if applied, err := jsonpatch.MergePatch(prev, data); err == nil {
+        merged = applied
+      }
+    }
+  } else {
+    merged = data
+  }
+  h.state[channel] = merged
+  h.versions[channel]++
+  version := h.versions[channel]
+  
+  // Save snapshot
+  snap := StateSnapshot{
+    Data:      append([]byte{}, merged...),
+    VersionNo: version,
+    Ts:        time.Now().UnixMilli(),
+  }
+  hist := h.history[channel]
+  hist = append(hist, snap)
+  if len(hist) > h.maxHistory {
+    hist = hist[len(hist)-h.maxHistory:]
+  }
+  h.history[channel] = hist
+  store := h.store
+  ttl := h.ttlSec
+  
+  h.mu.Unlock()
+
+  if store != nil {
+    _ = store.SaveSnapshot(context.Background(), channel, snap, ttl)
+    _ = store.AppendHistory(context.Background(), channel, snap, h.maxHistory, ttl)
+  }
+
+  msg := WSMessage{
+    Type:      "diff",
+    Channel:   channel,
+    Patch:     data,
+    Ts:        time.Now().UnixMilli(),
+    VersionNo: version,
+  }
+  raw, err := json.Marshal(msg)
+  if err != nil {
+    return
+  }
+  h.broadcast(channel, raw)
+}
+
+// Broadcast sends a message to all subscribers of a channel.
+// This is called by applyUpdate/applyDiff after creating the message.
+func (h *Hub) Broadcast(channel string, raw json.RawMessage) {
+  // This will be implemented by wsHub wrapper in main.go
+  // Hub only manages state, wsHub manages connections
+}
+
+// Get returns an event handler by name.
+func (h *Hub) Get(name string) (EventHandler, bool) {
+  h.mu.Lock()
+  defer h.mu.Unlock()
+  handler, ok := h.events[name]
+  return handler, ok
+}
+
+// SetBroadcaster sets a custom broadcast function (used by wsHub).
+type Broadcaster func(channel string, raw json.RawMessage)
+
+var globalBroadcaster Broadcaster
+
+func SetBroadcaster(fn Broadcaster) {
+  globalBroadcaster = fn
+}
+
+func (h *Hub) broadcast(channel string, raw json.RawMessage) {
+  if globalBroadcaster != nil {
+    globalBroadcaster(channel, raw)
+  }
+}
+`;

package/dist/go/goMod.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.goMod = void 0;
+exports.goMod = `module vira-engine-backend
+
+go 1.21
+
+require (
+  github.com/go-chi/chi/v5 v5.0.10
+  github.com/go-chi/cors v1.2.1
+  github.com/gorilla/websocket v1.5.1
+  github.com/google/uuid v1.5.0
+  github.com/rs/zerolog v1.32.0
+  github.com/jackc/pgx/v5 v5.5.4
+  github.com/redis/go-redis/v9 v9.5.1
+  github.com/segmentio/kafka-go v0.4.45
+  github.com/evanphx/json-patch/v5 v5.9.0
+  gopkg.in/yaml.v3 v3.0.1
+)
+`;

package/dist/go/kafkaGo.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kafkaGo = void 0;
+exports.kafkaGo = `package events
+
+import (
+  "context"
+  "fmt"
+  "time"
+
+  "github.com/segmentio/kafka-go"
+  "github.com/rs/zerolog"
+
+  "vira-engine-backend/internal/config"
+)
+
+type Client struct {
+  dialer *kafka.Dialer
+  cfg    config.Config
+  logger zerolog.Logger
+}
+
+func NewKafka(cfg config.Config, logger zerolog.Logger) (*Client, error) {
+  d := &kafka.Dialer{
+    Timeout:   5 * time.Second,
+    DualStack: true,
+  }
+  c := &Client{dialer: d, cfg: cfg, logger: logger}
+  if err := c.Ping(context.Background()); err != nil {
+    return nil, err
+  }
+  return c, nil
+}
+
+func (c *Client) Ping(ctx context.Context) error {
+  if len(c.cfg.Kafka.Brokers) == 0 {
+    return fmt.Errorf("no kafka brokers configured")
+  }
+  conn, err := c.dialer.DialContext(ctx, "tcp", c.cfg.Kafka.Brokers[0])
+  if err != nil {
+    return fmt.Errorf("dial kafka: %w", err)
+  }
+  _ = conn.Close()
+  return nil
+}
+
+func (c *Client) NewWriter(topic string) *kafka.Writer {
+  return &kafka.Writer{
+    Addr:         kafka.TCP(c.cfg.Kafka.Brokers...),
+    Topic:        topic,
+    RequiredAcks: kafka.RequireAll,
+    BatchTimeout: 10 * time.Millisecond,
+  }
+}
+
+func (c *Client) NewReader(topic string) *kafka.Reader {
+  return kafka.NewReader(kafka.ReaderConfig{
+    Brokers:        c.cfg.Kafka.Brokers,
+    GroupID:        c.cfg.Kafka.GroupID,
+    Topic:          topic,
+    StartOffset:    kafka.FirstOffset,
+    SessionTimeout: 10 * time.Second,
+    HeartbeatInterval: 3 * time.Second,
+    CommitInterval: 5 * time.Second,
+  })
+}
+
+func (c *Client) Close() error {
+  return nil
+}
+`;

package/dist/go/kafkaYaml.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kafkaYaml = void 0;
+exports.kafkaYaml = `brokers:
+- localhost:9092
+groupId: vira-engine
+topics:
+events: vira.events
+dlq: vira.events.dlq
+`;