@vibedash/client 0.2.0 → 0.3.0

package/dist/duckdb-singleton.d.ts

@@ -6,7 +6,7 @@
  */
 interface DuckDBInstance {
     query: (sql: string) => Promise<Record<string, unknown>[]>;
-    loadParquet: (name: string, url: string) => Promise<void>;
+    loadParquet: (name: string, url: string, forceReload?: boolean) => Promise<void>;
     isTableLoaded: (name: string) => boolean;
 }
 export declare function getDuckDB(): Promise<DuckDBInstance>;

package/dist/duckdb-singleton.js

@@ -27,13 +27,17 @@ async function initDuckDB() {
             const result = await conn.query(sql);
             return result.toArray().map((row) => row.toJSON());
         },
-        async loadParquet(name, url) {
-            if (loadedTables.has(name))
+        async loadParquet(name, url, forceReload = false) {
+            if (loadedTables.has(name) && !forceReload)
                 return;
             // Fetch the Parquet file and register it
             const response = await fetch(url);
             const buffer = await response.arrayBuffer();
             await db.registerFileBuffer(`${name}.parquet`, new Uint8Array(buffer));
+            // Drop existing table on force reload so we pick up the new data
+            if (forceReload && loadedTables.has(name)) {
+                await conn.query(`DROP TABLE IF EXISTS "${name}"`);
+            }
             await conn.query(`CREATE TABLE IF NOT EXISTS "${name}" AS SELECT * FROM read_parquet('${name}.parquet')`);
             loadedTables.add(name);
         },

package/dist/index.d.ts

@@ -1,3 +1,3 @@
 export { useQuery } from "./use-query";
-export { VibeDashProvider, useVibeDash } from "./provider";
+export { VibeDashProvider, useVibeDash, useRefreshAll } from "./provider";
 export type { UseQueryOptions, UseQueryResult, VibeDashConfig } from "./types";

package/dist/index.js

@@ -1,2 +1,2 @@
 export { useQuery } from "./use-query";
-export { VibeDashProvider, useVibeDash } from "./provider";
+export { VibeDashProvider, useVibeDash, useRefreshAll } from "./provider";

package/dist/provider.d.ts

@@ -1,5 +1,13 @@
 import type { VibeDashConfig } from "./types";
-export declare function VibeDashProvider({ apiUrl, projectSlug, apiKey, children, }: VibeDashConfig & {
+type RefetchFn = () => Promise<void>;
+interface VibeDashContextValue extends VibeDashConfig {
+    registerQuery: (name: string, fn: RefetchFn, cachedAt: Date | null) => void;
+    unregisterQuery: (name: string) => void;
+    refreshAll: () => Promise<void>;
+}
+export declare function VibeDashProvider({ apiUrl, projectSlug, dashboardSlug, apiKey, children, }: VibeDashConfig & {
     children: React.ReactNode;
 }): import("react/jsx-runtime").JSX.Element;
-export declare function useVibeDash(): VibeDashConfig;
+export declare function useVibeDash(): VibeDashContextValue;
+export declare function useRefreshAll(): () => Promise<void>;
+export {};

package/dist/provider.js

@@ -1,14 +1,103 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useContext } from "react";
+import { createContext, useContext, useCallback, useRef, useEffect, useState, } from "react";
 const VibeDashContext = createContext(null);
-export function VibeDashProvider({ apiUrl, projectSlug, apiKey, children, }) {
-    return (_jsx(VibeDashContext.Provider, { value: { apiUrl, projectSlug, apiKey }, children: children }));
+const POLL_INTERVAL_ACTIVE = 30000; // 30s when caching is on
+const POLL_INTERVAL_IDLE = 300000; // 5min when caching is off
+export function VibeDashProvider({ apiUrl, projectSlug, dashboardSlug, apiKey, children, }) {
+    const queryMap = useRef(new Map());
+    const [pollInterval, setPollInterval] = useState(POLL_INTERVAL_IDLE);
+    const registerQuery = useCallback((name, fn, cachedAt) => {
+        queryMap.current.set(name, { refetch: fn, cachedAt });
+    }, []);
+    const unregisterQuery = useCallback((name) => {
+        queryMap.current.delete(name);
+    }, []);
+    const refreshAll = useCallback(async () => {
+        const fns = Array.from(queryMap.current.values()).map((e) => e.refetch);
+        await Promise.allSettled(fns.map((fn) => fn()));
+    }, []);
+    // Auto-polling for live cache updates
+    useEffect(() => {
+        if (!dashboardSlug)
+            return;
+        let timeoutId;
+        let cancelled = false;
+        async function poll() {
+            if (cancelled)
+                return;
+            try {
+                const headers = {
+                    "Content-Type": "application/json",
+                };
+                if (apiKey) {
+                    headers["Authorization"] = `Bearer ${apiKey}`;
+                }
+                const res = await fetch(`${apiUrl}/query/status`, {
+                    method: "POST",
+                    headers,
+                    credentials: apiKey ? "omit" : "include",
+                    body: JSON.stringify({
+                        project_slug: projectSlug,
+                        dashboard_slug: dashboardSlug,
+                    }),
+                });
+                if (!res.ok)
+                    return;
+                const status = await res.json();
+                // Adjust poll interval based on cache mode
+                const newInterval = status.cache_mode && status.cache_mode !== "none"
+                    ? POLL_INTERVAL_ACTIVE
+                    : POLL_INTERVAL_IDLE;
+                setPollInterval(newInterval);
+                // Check for stale queries and refetch
+                if (status.queries) {
+                    for (const [queryName, info] of Object.entries(status.queries)) {
+                        const entry = queryMap.current.get(queryName);
+                        if (!entry || !info.cached_at)
+                            continue;
+                        const serverCachedAt = new Date(info.cached_at);
+                        const clientCachedAt = entry.cachedAt;
+                        // Server has newer data — trigger refetch
+                        if (!clientCachedAt ||
+                            serverCachedAt.getTime() > clientCachedAt.getTime()) {
+                            entry.refetch();
+                        }
+                    }
+                }
+            }
+            catch {
+                // Silently fail — will retry next interval
+            }
+            if (!cancelled) {
+                timeoutId = setTimeout(poll, pollInterval);
+            }
+        }
+        // Start first poll after a short delay (let queries mount first)
+        timeoutId = setTimeout(poll, 5000);
+        return () => {
+            cancelled = true;
+            clearTimeout(timeoutId);
+        };
+    }, [apiUrl, projectSlug, dashboardSlug, apiKey, pollInterval]);
+    return (_jsx(VibeDashContext.Provider, { value: {
+            apiUrl,
+            projectSlug,
+            dashboardSlug,
+            apiKey,
+            registerQuery,
+            unregisterQuery,
+            refreshAll,
+        }, children: children }));
 }
 export function useVibeDash() {
     const ctx = useContext(VibeDashContext);
     if (!ctx) {
         throw new Error("useVibeDash must be used within a <VibeDashProvider>. " +
-            "Wrap your app in <VibeDashProvider apiUrl=\"...\" projectSlug=\"...\">.");
+            'Wrap your app in <VibeDashProvider apiUrl="..." projectSlug="...">.');
     }
     return ctx;
 }
+export function useRefreshAll() {
+    const { refreshAll } = useVibeDash();
+    return refreshAll;
+}

package/dist/types.d.ts

@@ -3,6 +3,8 @@ export interface VibeDashConfig {
     apiUrl: string;
     /** The project slug (e.g. "data-man") */
     projectSlug: string;
+    /** The dashboard slug — enables auto-polling for live cache updates */
+    dashboardSlug?: string;
     /** API key for authentication (used in local dev, read from env) */
     apiKey?: string;
 }

package/dist/use-query.d.ts

@@ -8,6 +8,9 @@ import type { UseQueryOptions, UseQueryResult } from "./types";
  *
  * If no cache TTL is set, data comes from BigQuery live (existing behavior).
  *
+ * Data stays fresh automatically — when the Hub refreshes the cache in the
+ * background, the provider detects the change and triggers a reload.
+ *
  * Usage:
  * ```tsx
  * const { data, query, loading, cachedAt } = useQuery("monthly_revenue");

package/dist/use-query.js

@@ -9,6 +9,9 @@ import { useVibeDash } from "./provider";
  *
  * If no cache TTL is set, data comes from BigQuery live (existing behavior).
  *
+ * Data stays fresh automatically — when the Hub refreshes the cache in the
+ * background, the provider detects the change and triggers a reload.
+ *
  * Usage:
  * ```tsx
  * const { data, query, loading, cachedAt } = useQuery("monthly_revenue");
@@ -23,7 +26,7 @@ import { useVibeDash } from "./provider";
  * ```
  */
 export function useQuery(queryName, options) {
-    const { apiUrl, projectSlug, apiKey } = useVibeDash();
+    const { apiUrl, projectSlug, apiKey, registerQuery, unregisterQuery } = useVibeDash();
     const [data, setData] = useState(null);
     const [loading, setLoading] = useState(false);
     const [error, setError] = useState(null);
@@ -63,12 +66,13 @@ export function useQuery(queryName, options) {
                 const db = await getDuckDB();
                 // Force reload on refresh, otherwise reuse if already loaded
                 if (forceRefresh || !db.isTableLoaded(queryName)) {
-                    await db.loadParquet(queryName, body.parquet_url);
+                    await db.loadParquet(queryName, body.parquet_url, forceRefresh);
                 }
                 // Read all rows as default data
                 const allRows = await db.query(`SELECT * FROM "${queryName}"`);
                 setData(allRows);
-                setCachedAt(new Date(body.cached_at));
+                const newCachedAt = new Date(body.cached_at);
+                setCachedAt(newCachedAt);
                 // Expose local SQL query function
                 queryFnRef.current = (sql) => db.query(sql);
                 setQueryReady(true);
@@ -89,6 +93,16 @@ export function useQuery(queryName, options) {
             setLoading(false);
         }
     }, [apiUrl, projectSlug, queryName, apiKey]);
+    // Register this query by name so the provider can:
+    // 1. Call refetch via useRefreshAll()
+    // 2. Detect stale data via auto-polling and trigger refetch
+    const refetchFn = useCallback(() => fetchData(true), [fetchData]);
+    useEffect(() => {
+        if (enabled) {
+            registerQuery(queryName, refetchFn, cachedAt ?? null);
+            return () => unregisterQuery(queryName);
+        }
+    }, [enabled, queryName, refetchFn, cachedAt, registerQuery, unregisterQuery]);
     useEffect(() => {
         if (enabled) {
             fetchData();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibedash/client",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "React hooks for Vibe Dash dashboards — useQuery() with optional DuckDB-WASM caching",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",