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

package/dist/go/stateStore.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stateStore = void 0;
+exports.stateStore = `package events
+
+import (
+  "context"
+  "encoding/json"
+  "fmt"
+  "time"
+
+  "github.com/redis/go-redis/v9"
+)
+
+// StateStore abstracts persist/replay of channel state.
+type StateStore interface {
+  SaveSnapshot(ctx context.Context, channel string, snapshot StateSnapshot, ttlSec int) error
+  LoadSnapshot(ctx context.Context, channel string) (StateSnapshot, bool, error)
+  AppendHistory(ctx context.Context, channel string, snapshot StateSnapshot, maxLen int, ttlSec int) error
+  LoadHistory(ctx context.Context, channel string, fromVersion int64) ([]StateSnapshot, error)
+}
+
+// MemoryStore fallback (no-op persist)
+type MemoryStore struct{}
+
+func (MemoryStore) SaveSnapshot(ctx context.Context, channel string, snapshot StateSnapshot, ttlSec int) error { return nil }
+func (MemoryStore) LoadSnapshot(ctx context.Context, channel string) (StateSnapshot, bool, error) {
+  return StateSnapshot{}, false, nil
+}
+func (MemoryStore) AppendHistory(ctx context.Context, channel string, snapshot StateSnapshot, maxLen int, ttlSec int) error {
+  return nil
+}
+func (MemoryStore) LoadHistory(ctx context.Context, channel string, fromVersion int64) ([]StateSnapshot, error) {
+  return nil, nil
+}
+
+// RedisStore persists snapshots/history into Redis.
+type RedisStore struct {
+  client *redis.Client
+}
+
+func NewRedisStore(client *redis.Client) *RedisStore {
+  return &RedisStore{client: client}
+}
+
+// Keys:
+// snapshot:<channel> -> json StateSnapshot
+// history:<channel> -> list of json StateSnapshot (trimmed)
+
+func snapshotKey(ch string) string { return fmt.Sprintf("snapshot:%s", ch) }
+func historyKey(ch string) string  { return fmt.Sprintf("history:%s", ch) }
+
+func (s *RedisStore) SaveSnapshot(ctx context.Context, channel string, snapshot StateSnapshot, ttlSec int) error {
+  raw, err := json.Marshal(snapshot)
+  if err != nil {
+    return err
+  }
+  key := snapshotKey(channel)
+  if err := s.client.Set(ctx, key, raw, time.Duration(ttlSec)*time.Second).Err(); err != nil {
+    return err
+  }
+  return nil
+}
+
+func (s *RedisStore) LoadSnapshot(ctx context.Context, channel string) (StateSnapshot, bool, error) {
+  key := snapshotKey(channel)
+  val, err := s.client.Get(ctx, key).Bytes()
+  if err == redis.Nil {
+    return StateSnapshot{}, false, nil
+  }
+  if err != nil {
+    return StateSnapshot{}, false, err
+  }
+  var snap StateSnapshot
+  if err := json.Unmarshal(val, &snap); err != nil {
+    return StateSnapshot{}, false, err
+  }
+  return snap, true, nil
+}
+
+func (s *RedisStore) AppendHistory(ctx context.Context, channel string, snapshot StateSnapshot, maxLen int, ttlSec int) error {
+  raw, err := json.Marshal(snapshot)
+  if err != nil {
+    return err
+  }
+  key := historyKey(channel)
+  pipe := s.client.Pipeline()
+  pipe.RPush(ctx, key, raw)
+  if maxLen > 0 {
+    pipe.LTrim(ctx, key, int64(-maxLen), int64(-1))
+  }
+  if ttlSec > 0 {
+    pipe.Expire(ctx, key, time.Duration(ttlSec)*time.Second)
+  }
+  _, err = pipe.Exec(ctx)
+  return err
+}
+
+func (s *RedisStore) LoadHistory(ctx context.Context, channel string, fromVersion int64) ([]StateSnapshot, error) {
+  key := historyKey(channel)
+  items, err := s.client.LRange(ctx, key, 0, -1).Result()
+  if err == redis.Nil {
+    return nil, nil
+  }
+  if err != nil {
+    return nil, err
+  }
+  var out []StateSnapshot
+  for _, item := range items {
+    var snap StateSnapshot
+    if err := json.Unmarshal([]byte(item), &snap); err == nil {
+      if snap.VersionNo > fromVersion {
+        out = append(out, snap)
+      }
+    }
+  }
+  return out, nil
+}
+`;

package/dist/go/typesGo.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typesGo = void 0;
+exports.typesGo = `package types
+
+import "time"
+
+// Example shared model; extend with your domain structs.
+type User struct {
+  ID        int       \`json:"id"\`
+  Username  string    \`json:"username"\`
+  Role      string    \`json:"role"\`
+  UpdatedAt time.Time \`json:"updated_at"\`
+}
+`;

package/dist/go/useViraState.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useViraState = void 0;
+exports.useViraState = `import { useEffect, useMemo, useRef, useState, useCallback } from 'react';
+
+type Message = { type: string; channel?: string; data?: any; patch?: any; ts?: number; session?: string; interval?: number; versionNo?: number };
+const WS_PATH = '/ws';
+
+export function useViraState<T = any, C extends string = string>(channel: C, initial: T | null = null) {
+  const [data, setData] = useState<T | null>(initial);
+  const wsRef = useRef<WebSocket | null>(null);
+  const sessionRef = useRef<string | null>(null);
+  const bufferRef = useRef<Array<{ send: () => void; ver: number }>>([]);
+  const versionRef = useRef<number>(0);
+  const lastSentVersionRef = useRef<number>(0);
+  const url = useMemo(() => {
+    const api = import.meta.env.VITE_API_URL || 'http://localhost:8080';
+    return api.replace(/^http/, 'ws') + WS_PATH;
+  }, []);
+
+  const sendEvent = useCallback(
+    (name: string, payload: any) => {
+      const ver = versionRef.current;
+      const send = () =>
+        wsRef.current?.send(
+          JSON.stringify({ type: 'event', name, channel, data: payload, ts: Date.now(), versionNo: ver })
+        );
+      if (wsRef.current?.readyState === WebSocket.OPEN) {
+        send();
+        lastSentVersionRef.current = Math.max(lastSentVersionRef.current, ver);
+      } else {
+        bufferRef.current.push({ send, ver });
+      }
+    },
+    [channel]
+  );
+
+  const sendUpdate = useCallback(
+    (payload: any) => {
+      const ver = versionRef.current;
+      const send = () =>
+        wsRef.current?.send(
+          JSON.stringify({ type: 'update', channel, data: payload, ts: Date.now(), versionNo: ver })
+        );
+      if (wsRef.current?.readyState === WebSocket.OPEN) {
+        send();
+        lastSentVersionRef.current = Math.max(lastSentVersionRef.current, ver);
+      } else {
+        bufferRef.current.push({ send, ver });
+      }
+    },
+    [channel]
+  );
+
+  const sendDiff = useCallback(
+    (patch: any) => {
+      const ver = versionRef.current;
+      const send = () =>
+        wsRef.current?.send(
+          JSON.stringify({ type: 'diff', channel, patch, ts: Date.now(), versionNo: ver })
+        );
+      if (wsRef.current?.readyState === WebSocket.OPEN) {
+        send();
+        lastSentVersionRef.current = Math.max(lastSentVersionRef.current, ver);
+      } else {
+        bufferRef.current.push({ send, ver });
+      }
+    },
+    [channel]
+  );
+
+  useEffect(() => {
+    if (!channel) return;
+    let closed = false;
+    let timeout = 500;
+
+    const connect = () => {
+      if (closed) return;
+      const ws = new WebSocket(url);
+      wsRef.current = ws;
+
+      ws.onopen = () => {
+        ws.send(
+          JSON.stringify({
+            type: 'handshake',
+            client: 'vira-react',
+            version: '0.1',
+            authToken: import.meta.env.VITE_AUTH_TOKEN || '',
+            ts: Date.now(),
+            session: sessionRef.current || undefined,
+          })
+        );
+        ws.send(JSON.stringify({ type: 'sub', channels: [channel] }));
+        // flush buffered messages
+        bufferRef.current.splice(0).forEach(({ send, ver }) => {
+          if (ver <= lastSentVersionRef.current) return;
+          if (ws.readyState === WebSocket.OPEN) {
+            send();
+            lastSentVersionRef.current = Math.max(lastSentVersionRef.current, ver);
+          }
+        });
+      };
+
+      ws.onmessage = (evt) => {
+        try {
+          const msg = JSON.parse(evt.data as string) as Message;
+          if (msg.type === 'ack' && msg.session) {
+            sessionRef.current = msg.session;
+          }
+          if ((msg.type === 'update' || msg.type === 'event') && msg.channel === channel) {
+            if (msg.versionNo && msg.versionNo < versionRef.current) return;
+            if (msg.versionNo) versionRef.current = msg.versionNo;
+            setData(msg.data as T);
+          }
+          if (msg.type === 'diff' && msg.channel === channel && msg.patch && typeof msg.patch === 'object') {
+            if (msg.versionNo && msg.versionNo < versionRef.current) return;
+            if (msg.versionNo) versionRef.current = msg.versionNo;
+            setData((prev) => {
+              if (prev && typeof prev === 'object') {
+                return { ...(prev as any), ...(msg.patch as any) };
+              }
+              return (msg.patch as T) || prev;
+            });
+          }
+          if (msg.type === 'ping') {
+            ws.send(JSON.stringify({ type: 'pong', ts: Date.now() }));
+          }
+        } catch {
+          // ignore malformed
+        }
+      };
+
+      ws.onclose = () => {
+        wsRef.current = null;
+        if (closed) return;
+        setTimeout(connect, timeout);
+        timeout = Math.min(timeout * 2, 5000);
+      };
+
+      ws.onerror = () => {
+        ws.close();
+      };
+    };
+
+    connect();
+
+    return () => {
+      closed = true;
+      wsRef.current?.close();
+    };
+  }, [channel, url]);
+
+  return {
+    data,
+    sendEvent,
+    sendUpdate,
+    sendDiff,
+  };
+}
+`;

package/dist/go/useViraStream.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useViraStream = void 0;
+exports.useViraStream = `import { useEffect, useMemo, useRef, useState, useCallback } from 'react';
+
+type Message = { type: string; channel?: string; data?: any; session?: string; interval?: number; versionNo?: number };
+const WS_PATH = '/ws';
+
+export function useViraStream<T = any, C extends string = string>(channel: C) {
+  const [data, setData] = useState<T | null>(null);
+  const wsRef = useRef<WebSocket | null>(null);
+  const sessionRef = useRef<string | null>(null);
+  const bufferRef = useRef<Array<{ msg: any; ver: number }>>([]);
+  const versionRef = useRef<number>(0);
+  const lastSentVersionRef = useRef<number>(0);
+  const url = useMemo(() => {
+    const api = import.meta.env.VITE_API_URL || 'http://localhost:8080';
+    return api.replace(/^http/, 'ws') + WS_PATH;
+  }, []);
+
+  const sendEvent = useCallback(
+    (name: string, payload: any, msgId?: string) => {
+      const ver = versionRef.current;
+      const msg: any = { type: 'event', name, channel, data: payload, ts: Date.now(), versionNo: ver };
+      if (msgId) msg.msgId = msgId;
+      if (wsRef.current?.readyState === WebSocket.OPEN) {
+        wsRef.current.send(JSON.stringify(msg));
+        lastSentVersionRef.current = Math.max(lastSentVersionRef.current, ver);
+      } else {
+        bufferRef.current.push({ msg, ver });
+      }
+    },
+    [channel]
+  );
+
+  const sendUpdate = useCallback(
+    (payload: any, msgId?: string) => {
+      const ver = versionRef.current;
+      const msg: any = { type: 'update', channel, data: payload, ts: Date.now(), versionNo: ver };
+      if (msgId) msg.msgId = msgId;
+      if (wsRef.current?.readyState === WebSocket.OPEN) {
+        wsRef.current.send(JSON.stringify(msg));
+        lastSentVersionRef.current = Math.max(lastSentVersionRef.current, ver);
+      } else {
+        bufferRef.current.push({ msg, ver });
+      }
+    },
+    [channel]
+  );
+
+  const sendDiff = useCallback(
+    (patch: any, msgId?: string) => {
+      const ver = versionRef.current;
+      const msg: any = { type: 'diff', channel, patch, ts: Date.now(), versionNo: ver };
+      if (msgId) msg.msgId = msgId;
+      if (wsRef.current?.readyState === WebSocket.OPEN) {
+        wsRef.current.send(JSON.stringify(msg));
+        lastSentVersionRef.current = Math.max(lastSentVersionRef.current, ver);
+      } else {
+        bufferRef.current.push({ msg, ver });
+      }
+    },
+    [channel]
+  );
+
+  useEffect(() => {
+    if (!channel) return;
+    let closed = false;
+    let timeout = 500;
+    let pingIntervalId: any;
+
+    const connect = () => {
+      if (closed) return;
+      const ws = new WebSocket(url);
+      wsRef.current = ws;
+
+      ws.onopen = () => {
+        console.log(\`WS connected to \${url}\`);
+        ws.send(
+          JSON.stringify({
+            type: 'handshake',
+            client: 'vira-react',
+            version: '0.1',
+            authToken: import.meta.env.VITE_AUTH_TOKEN || '',
+            session: sessionRef.current || undefined,
+            ts: Date.now(),
+          })
+        );
+        ws.send(JSON.stringify({ type: 'sub', channels: [channel] }));
+        // Resend buffered messages
+        const buffered = bufferRef.current.splice(0);
+        buffered.forEach(({ msg, ver }) => {
+          if (ver <= lastSentVersionRef.current) return;
+          if (ws.readyState === WebSocket.OPEN) {
+            ws.send(JSON.stringify(msg));
+            lastSentVersionRef.current = Math.max(lastSentVersionRef.current, ver);
+          }
+        });
+        timeout = 500; // Reset timeout on successful connection
+      };
+
+      ws.onmessage = (evt) => {
+        try {
+          const msg = JSON.parse(evt.data as string) as Message;
+          if (msg.type === 'ack' && msg.session) {
+            sessionRef.current = msg.session;
+            if (msg.interval) {
+              clearInterval(pingIntervalId);
+              pingIntervalId = setInterval(() => {
+                if (ws.readyState === WebSocket.OPEN) {
+                  ws.send(JSON.stringify({ type: 'ping', ts: Date.now() }));
+                }
+              }, msg.interval);
+            }
+          }
+          if ((msg.type === 'update' || msg.type === 'event') && msg.channel === channel) {
+            if (msg.versionNo && msg.versionNo < versionRef.current) return;
+            if (msg.versionNo) versionRef.current = msg.versionNo;
+            setData(msg.data as T);
+          }
+          if (msg.type === 'diff' && msg.channel === channel && msg.patch && typeof msg.patch === 'object') {
+            setData((prev) => {
+              if (prev && typeof prev === 'object') {
+                return { ...(prev as any), ...(msg.patch as any) };
+              }
+              return (msg.patch as T) || prev;
+            });
+          }
+          if (msg.type === 'ping') {
+            ws.send(JSON.stringify({ type: 'pong', ts: Date.now() }));
+          }
+        } catch {
+          // ignore malformed
+        }
+      };
+
+      ws.onclose = () => {
+        console.log('WS disconnected. Reconnecting...');
+        wsRef.current = null;
+        clearInterval(pingIntervalId);
+        if (closed) return;
+        setTimeout(connect, timeout);
+        timeout = Math.min(timeout * 2, 30000); // Max 30 seconds
+      };
+
+      ws.onerror = () => {
+        ws.close();
+      };
+    };
+
+    connect();
+
+    return () => {
+      closed = true;
+      clearInterval(pingIntervalId);
+      wsRef.current?.close();
+    };
+  }, [channel, url]);
+
+  return {
+    data,
+    sendEvent,
+    sendUpdate,
+    sendDiff,
+  };
+}
+`;