fixes: #28, #27, better tab management and minor bugs

Author: caioricciuti

package.json

@@ -1,6 +1,6 @@
 {
   "name": "gigapi-ui",
-  "version": "1.0.18",
+  "version": "1.0.19",
   "type": "module",
   "description": "UI interface for GigAPI: The Infinite Timeseries Lakehouse. GigAPI UI provides a slick web interface to query time-series using GigAPI Catalog Metadata + DuckDB",
   "scripts": {

src/atoms/database-atoms.ts

@@ -822,7 +822,7 @@ export const isCacheValidAtom = atom((get) => {
 export const cacheRefreshLoadingAtom = atom<boolean>(false);
 
 // Refresh cache
-export const refreshSchemaCacheAtom = atom(null, async (get, set) => {
+export const refreshSchemaCacheAtom = atom(null, async (_get, set) => {
   set(cacheRefreshLoadingAtom, true);
   const startTime = Date.now();
 
@@ -997,6 +997,7 @@ export const fetchFreshDatabasesAtom = atom(
         .filter(Boolean) || [];
 
       set(freshDatabasesAtom, databases);
+      set(freshDatabasesLoadedAtom, true);
       return databases;
     } catch (error) {
       console.error("[Fresh Databases] Failed to fetch:", error);
@@ -1008,17 +1009,16 @@ export const fetchFreshDatabasesAtom = atom(
   }
 );
 
-// Fresh tables - always fetch from API
+// Fresh tables - always fetch from API (keyed by database)
 export const freshTablesLoadingAtom = atom<boolean>(false);
-export const freshTablesAtom = atom<string[]>([]);
+export const freshTablesAtom = atom<Record<string, string[]>>({});
 
 export const fetchFreshTablesAtom = atom(
   null,
   async (get, set, database: string) => {
     const apiUrl = get(apiUrlAtom);
 
     if (!database) {
-      set(freshTablesAtom, []);
       return [];
     }
 
@@ -1034,29 +1034,42 @@ export const fetchFreshTablesAtom = atom(
         ?.map((item: any) => item.table_name || item.Table || item.name)
         .filter(Boolean) || [];
 
-      set(freshTablesAtom, tables);
+      // Store tables keyed by database
+      set(freshTablesAtom, (prev) => ({
+        ...prev,
+        [database]: tables
+      }));
+      // Mark this database as having tables loaded
+      set(freshTablesLoadedForAtom, (prev: Set<string>) => {
+        const newSet = new Set(prev);
+        newSet.add(database);
+        return newSet;
+      });
       return tables;
     } catch (error) {
       console.error(`[Fresh Tables] Failed to fetch for ${database}:`, error);
-      set(freshTablesAtom, []);
+      // Don't clear all tables, just mark this database as empty
+      set(freshTablesAtom, (prev) => ({
+        ...prev,
+        [database]: []
+      }));
       return [];
     } finally {
       set(freshTablesLoadingAtom, false);
     }
   }
 );
 
-// Fresh schema - always fetch from API
+// Fresh schema - always fetch from API (keyed by database.table)
 export const freshSchemaLoadingAtom = atom<boolean>(false);
-export const freshSchemaAtom = atom<ColumnSchema[]>([]);
+export const freshSchemaAtom = atom<Record<string, ColumnSchema[]>>({});
 
 export const fetchFreshSchemaAtom = atom(
   null,
   async (get, set, { database, table }: { database: string; table: string }) => {
     const apiUrl = get(apiUrlAtom);
 
     if (!database || !table) {
-      set(freshSchemaAtom, []);
       return [];
     }
 
@@ -1093,18 +1106,47 @@ export const fetchFreshSchemaAtom = atom(
         };
       });
 
-      set(freshSchemaAtom, schemaWithTimeUnits);
+      // Store schema keyed by database.table
+      const schemaKey = `${database}.${table}`;
+      set(freshSchemaAtom, (prev) => ({
+        ...prev,
+        [schemaKey]: schemaWithTimeUnits
+      }));
+      // Mark this table schema as loaded
+      set(freshSchemasLoadedForAtom, (prev: Set<string>) => {
+        const newSet = new Set(prev);
+        newSet.add(schemaKey);
+        return newSet;
+      });
       return schemaWithTimeUnits;
     } catch (error) {
       console.error(`[Fresh Schema] Failed to fetch for ${database}.${table}:`, error);
-      set(freshSchemaAtom, []);
+      // Don't clear all schemas, just mark this table as empty
+      const schemaKey = `${database}.${table}`;
+      set(freshSchemaAtom, (prev) => ({
+        ...prev,
+        [schemaKey]: []
+      }));
       return [];
     } finally {
       set(freshSchemaLoadingAtom, false);
     }
   }
 );
 
+// ============================================================================
+// Fresh Data Tracking Atoms - Track what has been loaded
+// ============================================================================
+
+// Track if databases have been loaded in this session
+export const freshDatabasesLoadedAtom = atom<boolean>(false);
+
+// Track which database tables have been loaded
+export const freshTablesLoadedForAtom = atom<Set<string>>(new Set<string>());
+
+// Track which schemas have been loaded (key: "database.table")
+export const freshSchemasLoadedForAtom = atom<Set<string>>(new Set<string>());
+
 // ============================================================================
 // Sample Data Cache Management
 // ============================================================================

src/atoms/query-atoms.ts

@@ -1,5 +1,4 @@
 import { atom } from "jotai";
-import { atomWithStorage } from "jotai/utils";
 import axios from "axios";
 import { QueryProcessor } from "@/lib/query-processor";
 import { toast } from "sonner";
@@ -13,20 +12,26 @@ export type { QueryHistoryItem };
 // Import tab atoms
 import { 
   currentTabQueryAtom, 
-  currentTabDatabaseAtom,
-  currentTabTableAtom,
-  currentTabTimeFieldAtom,
-  currentTabTimeRangeAtom,
   currentTabQueryHistoryAtom, 
-  addToTabQueryHistoryAtom, 
   clearTabQueryHistoryAtom,
   currentTabQueryResultsAtom,
   currentTabQueryErrorAtom,
   currentTabQueryLoadingAtom,
   currentTabQueryExecutionTimeAtom,
   currentTabQueryMetricsAtom,
   currentTabRawQueryResponseAtom,
-  currentTabProcessedQueryAtom
+  currentTabProcessedQueryAtom,
+  activeTabIdAtom,
+  addRunningQueryAtom,
+  removeRunningQueryAtom,
+  updateTabQueryResultsByIdAtom,
+  updateTabQueryErrorByIdAtom,
+  updateTabQueryLoadingByIdAtom,
+  updateTabQueryMetricsByIdAtom,
+  updateTabRawResponseByIdAtom,
+  updateTabProcessedQueryByIdAtom,
+  addToTabQueryHistoryByIdAtom,
+  getTabByIdAtom
 } from "./tab-atoms";
 
 // Alias the tab-aware atoms for backward compatibility
@@ -48,11 +53,27 @@ export const setQueryAtom = atom(null, (_get, set, query: string) => {
 });
 
 export const executeQueryAtom = atom(null, async (get, set) => {
-  const query = get(queryAtom);
-  const selectedDb = get(currentTabDatabaseAtom);
-  const selectedTable = get(currentTabTableAtom);
-  const selectedTimeField = get(currentTabTimeFieldAtom);
-  const timeRange = get(currentTabTimeRangeAtom);
+  // Capture the tab ID at the start of execution
+  const executeTabId = get(activeTabIdAtom);
+  if (!executeTabId) {
+    toast.error("No active tab");
+    return;
+  }
+
+  // Get the tab data at the time of execution
+  const getTabById = get(getTabByIdAtom);
+  const executeTab = getTabById(executeTabId);
+  if (!executeTab) {
+    toast.error("Tab not found");
+    return;
+  }
+
+  // Use the tab's data at execution time
+  const query = executeTab.query;
+  const selectedDb = executeTab.database;
+  const selectedTable = executeTab.table;
+  const selectedTimeField = executeTab.timeField;
+  const timeRange = executeTab.timeRange;
   const tableSchema = get(tableSchemaAtom);
   const apiUrl = get(apiUrlAtom);
 
@@ -66,9 +87,13 @@ export const executeQueryAtom = atom(null, async (get, set) => {
     return;
   }
 
-  set(queryLoadingAtom, true);
-  set(queryErrorAtom, null);
-  set(queryResultsAtom, null); // Clear previous results
+  // Update loading state for the specific tab
+  set(updateTabQueryLoadingByIdAtom, { tabId: executeTabId, loading: true });
+  set(updateTabQueryErrorByIdAtom, { tabId: executeTabId, error: null });
+  set(updateTabQueryResultsByIdAtom, { tabId: executeTabId, results: null }); // Clear previous results
+  
+  // Mark this tab as having a running query
+  set(addRunningQueryAtom, executeTabId);
 
   const startTime = Date.now();
 
@@ -112,13 +137,13 @@ export const executeQueryAtom = atom(null, async (get, set) => {
       });
 
       if (processed.errors.length > 0) {
-        set(queryErrorAtom, processed.errors.join("; "));
+        set(updateTabQueryErrorByIdAtom, { tabId: executeTabId, error: processed.errors.join("; ") });
         toast.error(`Query processing error: ${processed.errors[0]}`);
         return;
       }
 
       processedQuery = processed.query;
-      set(processedQueryAtom, processedQuery);
+      set(updateTabProcessedQueryByIdAtom, { tabId: executeTabId, query: processedQuery });
     }
 
     // Execute the processed query
@@ -176,23 +201,25 @@ export const executeQueryAtom = atom(null, async (get, set) => {
     }
 
     // Store raw response for Raw tab
-    set(rawQueryResponseAtom, rawResponse);
+    set(updateTabRawResponseByIdAtom, { tabId: executeTabId, response: rawResponse });
 
     const executionTime = Date.now() - startTime;
-    set(queryResultsAtom, parsedResults);
-    set(queryExecutionTimeAtom, executionTime);
+    set(updateTabQueryResultsByIdAtom, { tabId: executeTabId, results: parsedResults });
 
     // Calculate size properly based on the raw response
     const responseSize =
       typeof result === "string"
         ? result.length
         : JSON.stringify(result).length;
 
-    set(queryMetricsAtom, {
-      executionTime,
-      rowCount: parsedResults.length,
-      size: responseSize,
-      processedRows: parsedResults.length,
+    set(updateTabQueryMetricsByIdAtom, {
+      tabId: executeTabId,
+      metrics: {
+        executionTime,
+        rowCount: parsedResults.length,
+        size: responseSize,
+        processedRows: parsedResults.length,
+      }
     });
 
     // Add to history with full context
@@ -211,8 +238,8 @@ export const executeQueryAtom = atom(null, async (get, set) => {
       rowCount: parsedResults.length,
     };
 
-    // Add to current tab's history
-    set(addToTabQueryHistoryAtom, historyItem);
+    // Add to the specific tab's history
+    set(addToTabQueryHistoryByIdAtom, { tabId: executeTabId, historyItem });
   } catch (error: any) {
     let errorMessage = "Query failed";
 
@@ -245,8 +272,8 @@ export const executeQueryAtom = atom(null, async (get, set) => {
       errorMessage = error.message;
     }
 
-    set(queryErrorAtom, errorMessage);
-    set(queryResultsAtom, null); // Clear results on error
+    set(updateTabQueryErrorByIdAtom, { tabId: executeTabId, error: errorMessage });
+    set(updateTabQueryResultsByIdAtom, { tabId: executeTabId, results: null }); // Clear results on error
 
     // Add failed query to history with full context
     const historyItem: QueryHistoryItem = {
@@ -262,10 +289,14 @@ export const executeQueryAtom = atom(null, async (get, set) => {
       error: errorMessage,
     };
 
-    // Add to current tab's history
-    set(addToTabQueryHistoryAtom, historyItem);
+    // Add to the specific tab's history
+    set(addToTabQueryHistoryByIdAtom, { tabId: executeTabId, historyItem });
   } finally {
-    set(queryLoadingAtom, false);
+    // Update loading state for the specific tab
+    set(updateTabQueryLoadingByIdAtom, { tabId: executeTabId, loading: false });
+    
+    // Remove this tab from running queries
+    set(removeRunningQueryAtom, executeTabId);
   }
 });