insforge 0.3.3 → 1.2.10

package/frontend/src/features/database/constants.ts

@@ -1,7 +1,6 @@
 import { Type, Clock, Calendar, Hash, Percent, ToggleLeft, Fingerprint, Code } from 'lucide-react';
 import { ColumnType } from '@insforge/shared-schemas';
 
-// Icon mapping for field types
 export const columnTypeIcons: Record<ColumnType, React.ComponentType<{ className?: string }>> = {
   [ColumnType.STRING]: Type,
   [ColumnType.DATE]: Calendar,
@@ -13,7 +12,6 @@ export const columnTypeIcons: Record<ColumnType, React.ComponentType<{ className
   [ColumnType.JSON]: Code,
 };
 
-// Field type descriptions
 export const columnTypeDescriptions: Record<ColumnType, string> = {
   [ColumnType.STRING]: 'Text values of any length',
   [ColumnType.INTEGER]: 'Whole numbers without decimals',
@@ -24,3 +22,31 @@ export const columnTypeDescriptions: Record<ColumnType, string> = {
   [ColumnType.UUID]: 'Unique identifiers (auto-generated)',
   [ColumnType.JSON]: 'Complex structured data',
 };
+
+/**
+ * System tables that should be filtered out from user-facing database views
+ */
+export const SYSTEM_TABLES = ['users'];
+export const SYSTEM_FUNCTIONS = [
+  'create_default_policies',
+  'create_policies_after_rls',
+  'email',
+  'reload_postgrest_schema',
+  'role',
+  'uid',
+  'update_updated_at_column',
+];
+
+/**
+ * Check if a table name is a system table
+ */
+export function isSystemTable(tableName: string): boolean {
+  return tableName.startsWith('_') || SYSTEM_TABLES.includes(tableName);
+}
+
+/**
+ * Check if a function name is a system function
+ */
+export function isSystemFunction(functionName: string): boolean {
+  return SYSTEM_FUNCTIONS.includes(functionName);
+}

package/frontend/src/features/database/contexts/SQLEditorContext.tsx

@@ -0,0 +1,188 @@
+import { createContext, useContext, useState, ReactNode, useEffect, useRef } from 'react';
+
+export interface SQLTab {
+  id: string;
+  name: string;
+  query: string;
+}
+
+interface SQLEditorContextType {
+  tabs: SQLTab[];
+  activeTabId: string;
+  activeTab: SQLTab | undefined;
+  addTab: (initialQuery?: string, initialName?: string) => void;
+  removeTab: (tabId: string) => void;
+  setActiveTab: (tabId: string) => void;
+  updateTabQuery: (tabId: string, query: string) => void;
+  updateTabName: (tabId: string, name: string) => void;
+}
+
+const SQLEditorContext = createContext<SQLEditorContextType | undefined>(undefined);
+
+interface SQLEditorProviderProps {
+  children: ReactNode;
+}
+
+const STORAGE_KEY = 'sql-editor-tabs';
+const ACTIVE_TAB_KEY = 'sql-editor-active-tab';
+const DEBOUNCE_DELAY = 500; // Save after 500ms of inactivity
+
+let tabCounter = 1;
+
+// Load tabs from localStorage
+function loadTabsFromStorage(): SQLTab[] {
+  try {
+    const stored = localStorage.getItem(STORAGE_KEY);
+    if (stored) {
+      const tabs = JSON.parse(stored) as SQLTab[];
+      // Update tabCounter to be higher than any existing tab number
+      tabs.forEach((tab) => {
+        const match = tab.name.match(/Query (\d+)/);
+        if (match) {
+          const num = parseInt(match[1], 10);
+          if (num >= tabCounter) {
+            tabCounter = num;
+          }
+        }
+      });
+      return tabs.length > 0 ? tabs : getDefaultTabs();
+    }
+  } catch (error) {
+    console.error('Failed to load tabs from localStorage:', error);
+  }
+  return getDefaultTabs();
+}
+
+function getDefaultTabs(): SQLTab[] {
+  return [
+    {
+      id: 'tab-1',
+      name: 'Query 1',
+      query: '',
+    },
+  ];
+}
+
+function loadActiveTabFromStorage(): string {
+  try {
+    const stored = localStorage.getItem(ACTIVE_TAB_KEY);
+    return stored || 'tab-1';
+  } catch (error) {
+    console.error('Failed to load active tab from localStorage:', error);
+    return 'tab-1';
+  }
+}
+
+export function SQLEditorProvider({ children }: SQLEditorProviderProps) {
+  const [tabs, setTabs] = useState<SQLTab[]>(loadTabsFromStorage);
+  const [activeTabId, setActiveTabId] = useState(loadActiveTabFromStorage);
+  const saveTimeoutRef = useRef<NodeJS.Timeout | null>(null);
+  const tabsRef = useRef<SQLTab[]>(tabs);
+
+  const activeTab = tabs.find((tab) => tab.id === activeTabId);
+
+  // Debounced save to localStorage
+  const debouncedSave = (tabsToSave: SQLTab[]) => {
+    if (saveTimeoutRef.current) {
+      clearTimeout(saveTimeoutRef.current);
+    }
+    saveTimeoutRef.current = setTimeout(() => {
+      try {
+        localStorage.setItem(STORAGE_KEY, JSON.stringify(tabsToSave));
+      } catch (error) {
+        console.error('Failed to save tabs to localStorage:', error);
+      }
+    }, DEBOUNCE_DELAY);
+  };
+
+  // Save active tab immediately (no debounce needed for this)
+  useEffect(() => {
+    try {
+      localStorage.setItem(ACTIVE_TAB_KEY, activeTabId);
+    } catch (error) {
+      console.error('Failed to save active tab to localStorage:', error);
+    }
+  }, [activeTabId]);
+
+  // Debounced save for tabs changes
+  useEffect(() => {
+    // Keep ref in sync with latest tabs
+    tabsRef.current = tabs;
+    debouncedSave(tabs);
+    // Cleanup timeout on unmount and flush pending save
+    return () => {
+      if (saveTimeoutRef.current) {
+        clearTimeout(saveTimeoutRef.current);
+        // Flush the pending save to avoid data loss
+        try {
+          localStorage.setItem(STORAGE_KEY, JSON.stringify(tabsRef.current));
+        } catch (error) {
+          console.error('Failed to save tabs to localStorage:', error);
+        }
+      }
+    };
+  }, [tabs]);
+
+  const addTab = (initialQuery?: string, initialName?: string) => {
+    tabCounter++;
+    const newTab: SQLTab = {
+      id: `tab-${Date.now()}`,
+      name: initialName || `Query ${tabCounter}`,
+      query: initialQuery || '',
+    };
+    setTabs((prev) => [...prev, newTab]);
+    setActiveTabId(newTab.id);
+  };
+
+  const removeTab = (tabId: string) => {
+    setTabs((prev) => {
+      const newTabs = prev.filter((tab) => tab.id !== tabId);
+      // Don't allow removing the last tab
+      if (newTabs.length === 0) {
+        return prev;
+      }
+      // If we're removing the active tab, switch to the first remaining tab
+      if (tabId === activeTabId) {
+        setActiveTabId(newTabs[0].id);
+      }
+      return newTabs;
+    });
+  };
+
+  const setActiveTab = (tabId: string) => {
+    setActiveTabId(tabId);
+  };
+
+  const updateTabQuery = (tabId: string, query: string) => {
+    setTabs((prev) => prev.map((tab) => (tab.id === tabId ? { ...tab, query } : tab)));
+  };
+
+  const updateTabName = (tabId: string, name: string) => {
+    setTabs((prev) => prev.map((tab) => (tab.id === tabId ? { ...tab, name } : tab)));
+  };
+
+  return (
+    <SQLEditorContext.Provider
+      value={{
+        tabs,
+        activeTabId,
+        activeTab,
+        addTab,
+        removeTab,
+        setActiveTab,
+        updateTabQuery,
+        updateTabName,
+      }}
+    >
+      {children}
+    </SQLEditorContext.Provider>
+  );
+}
+
+export function useSQLEditorContext() {
+  const context = useContext(SQLEditorContext);
+  if (context === undefined) {
+    throw new Error('useSQLEditorContext must be used within a SQLEditorProvider');
+  }
+  return context;
+}

package/frontend/src/features/database/helpers.ts

@@ -1,4 +1,4 @@
-import { jsonSchema } from '@/lib/utils/validation-schemas';
+import { jsonSchema } from '@/lib/utils/schemaValidations';
 import { ColumnSchema, ColumnType } from '@insforge/shared-schemas';
 import { z } from 'zod';
 
@@ -60,7 +60,7 @@ export function buildDynamicSchema(columns: ColumnSchema[]) {
         }
         break;
       default:
-        fieldSchema = z.any();
+        fieldSchema = z.unknown();
         if (column.isNullable) {
           fieldSchema = fieldSchema.nullable().optional();
         }

package/frontend/src/features/database/hooks/useCSVImport.ts

@@ -0,0 +1,29 @@
+import { useMutation } from '@tanstack/react-query';
+import { recordService, CSVImportResponse } from '../services/record.service.js';
+
+interface UseCSVImportOptions {
+  onSuccess?: (data: CSVImportResponse) => void;
+  onError?: (error: Error) => void;
+}
+
+export function useCSVImport(tableName: string, options?: UseCSVImportOptions) {
+  const mutation = useMutation({
+    mutationFn: async (file: File) => {
+      return recordService.importCSV(tableName, file);
+    },
+    onSuccess: (data) => {
+      // Always call onSuccess, let the component decide what to do based on data.success
+      options?.onSuccess?.(data);
+    },
+    onError: (error) => {
+      options?.onError?.(error);
+    },
+  });
+
+  return {
+    mutate: mutation.mutate,
+    reset: mutation.reset,
+    isPending: mutation.isPending,
+    error: mutation.error,
+  };
+}

package/frontend/src/features/database/hooks/useFullMetadata.ts

@@ -0,0 +1,18 @@
+import { useQuery } from '@tanstack/react-query';
+import { advanceService } from '../services/advance.service';
+
+export function useFullMetadata(enabled = false) {
+  const { data, isLoading, error, refetch } = useQuery({
+    queryKey: ['database', 'metadata', 'full'],
+    queryFn: () => advanceService.getDatabaseFullMetadata(),
+    staleTime: 5 * 60 * 1000, // Cache for 5 minutes
+    enabled,
+  });
+
+  return {
+    data,
+    isLoading,
+    error,
+    refetch,
+  };
+}

package/frontend/src/features/database/hooks/useRawSQL.ts

@@ -0,0 +1,55 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { advanceService, RawSQLResponse } from '../services/advance.service';
+import { useToast } from '@/lib/hooks/useToast';
+
+interface UseRawSQLOptions {
+  onSuccess?: (data: RawSQLResponse) => void;
+  onError?: (error: Error) => void;
+  showSuccessToast?: boolean;
+  showErrorToast?: boolean;
+}
+
+interface RawSQLParams {
+  query: string;
+  params?: unknown[];
+}
+
+export function useRawSQL(options?: UseRawSQLOptions) {
+  const { showToast } = useToast();
+  const queryClient = useQueryClient();
+
+  const mutation = useMutation({
+    mutationFn: async ({ query, params = [] }: RawSQLParams) => {
+      return advanceService.runRawSQL(query, params);
+    },
+    onSuccess: (data) => {
+      // Invalidate database schema queries to ensure UI reflects any schema changes
+      void queryClient.invalidateQueries({ queryKey: ['tables'] });
+      void queryClient.invalidateQueries({ queryKey: ['tables', 'schemas'] });
+
+      if (options?.showSuccessToast !== false) {
+        const message = data.message || 'SQL query executed successfully';
+        showToast(message, 'success');
+      }
+      options?.onSuccess?.(data);
+    },
+    onError: (error: Error) => {
+      if (options?.showErrorToast !== false) {
+        const errorMessage = error instanceof Error ? error.message : 'Failed to execute SQL query';
+        showToast(errorMessage, 'error');
+      }
+      options?.onError?.(error);
+    },
+  });
+
+  return {
+    executeSQL: mutation.mutate,
+    executeSQLAsync: mutation.mutateAsync,
+    reset: mutation.reset,
+    isPending: mutation.isPending,
+    isSuccess: mutation.isSuccess,
+    isError: mutation.isError,
+    error: mutation.error,
+    data: mutation.data,
+  };
+}

package/frontend/src/features/database/hooks/useRecords.ts

@@ -0,0 +1,139 @@
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import { recordService } from '../services/record.service';
+import { useToast } from '@/lib/hooks/useToast';
+import { ConvertedValue } from '@/components/datagrid/datagridTypes';
+
+export function useRecords(tableName: string) {
+  const queryClient = useQueryClient();
+  const { showToast } = useToast();
+
+  // Hook to fetch table records with pagination, search, and sorting
+  const useTableRecords = (
+    limit = 10,
+    offset = 0,
+    searchQuery?: string,
+    sortColumns?: { columnKey: string; direction: string }[],
+    enabled = true
+  ) => {
+    return useQuery({
+      queryKey: ['records', tableName, limit, offset, searchQuery, JSON.stringify(sortColumns)],
+      queryFn: () =>
+        recordService.getTableRecords(tableName, limit, offset, searchQuery, sortColumns),
+      enabled: enabled && !!tableName,
+      staleTime: 30 * 1000, // Cache for 30 seconds
+    });
+  };
+
+  // Hook to fetch records with custom query params
+  const useRecordsWithQuery = (queryParams: string = '', enabled = true) => {
+    return useQuery({
+      queryKey: ['records', tableName, 'query', queryParams],
+      queryFn: () => recordService.getRecords(tableName, queryParams),
+      enabled: enabled && !!tableName,
+      staleTime: 30 * 1000,
+    });
+  };
+
+  // Hook to fetch a single record by foreign key value
+  const useRecordByForeignKey = (columnName: string, value: string, enabled = true) => {
+    return useQuery({
+      queryKey: ['records', tableName, 'foreignKey', columnName, value],
+      queryFn: () => recordService.getRecordByForeignKeyValue(tableName, columnName, value),
+      enabled: enabled && !!tableName && !!columnName && !!value,
+      staleTime: 30 * 1000,
+    });
+  };
+
+  // Mutation to create a single record
+  const createRecordMutation = useMutation({
+    mutationFn: (data: { [key: string]: ConvertedValue }) =>
+      recordService.createRecord(tableName, data),
+    onSuccess: () => {
+      void queryClient.invalidateQueries({ queryKey: ['records', tableName] });
+      void queryClient.invalidateQueries({ queryKey: ['table', tableName] });
+      showToast('Record created successfully', 'success');
+    },
+    onError: (error: Error) => {
+      const errorMessage = error instanceof Error ? error.message : 'Failed to create record';
+      showToast(errorMessage, 'error');
+    },
+  });
+
+  // Mutation to create multiple records
+  const createRecordsMutation = useMutation({
+    mutationFn: (records: { [key: string]: ConvertedValue }[]) =>
+      recordService.createRecords(tableName, records),
+    onSuccess: () => {
+      void queryClient.invalidateQueries({ queryKey: ['records', tableName] });
+      void queryClient.invalidateQueries({ queryKey: ['table', tableName] });
+      showToast('Records created successfully', 'success');
+    },
+    onError: (error: Error) => {
+      const errorMessage = error instanceof Error ? error.message : 'Failed to create records';
+      showToast(errorMessage, 'error');
+    },
+  });
+
+  // Mutation to update a record
+  const updateRecordMutation = useMutation({
+    mutationFn: ({
+      pkColumn,
+      pkValue,
+      data,
+    }: {
+      pkColumn: string;
+      pkValue: string;
+      data: { [key: string]: ConvertedValue };
+    }) => recordService.updateRecord(tableName, pkColumn, pkValue, data),
+    onSuccess: () => {
+      void queryClient.invalidateQueries({ queryKey: ['records', tableName] });
+      void queryClient.invalidateQueries({ queryKey: ['table', tableName] });
+      showToast('Record updated successfully', 'success');
+    },
+    onError: (error: Error) => {
+      const errorMessage = error instanceof Error ? error.message : 'Failed to update record';
+      showToast(errorMessage, 'error');
+    },
+  });
+
+  // Mutation to delete a record
+  const deleteRecordsMutation = useMutation({
+    mutationFn: (variables: { pkColumn: string; pkValues: string[] }) =>
+      recordService.deleteRecords(tableName, variables.pkColumn, variables.pkValues),
+    onSuccess: (_data, variables) => {
+      void queryClient.invalidateQueries({ queryKey: ['records', tableName] });
+      void queryClient.invalidateQueries({ queryKey: ['table', tableName] });
+      const count = variables.pkValues.length;
+      if (count === 1) {
+        showToast('Record deleted successfully', 'success');
+      } else {
+        showToast(`${count} records deleted successfully`, 'success');
+      }
+    },
+    onError: (error: Error, variables) => {
+      const count = variables.pkValues.length;
+      const recordText = count === 1 ? 'record' : 'records';
+      const errorMessage =
+        error instanceof Error ? error.message : `Failed to delete ${recordText}`;
+      showToast(errorMessage, 'error');
+    },
+  });
+
+  return {
+    // Hooks for fetching
+    useTableRecords,
+    useRecordsWithQuery,
+    useRecordByForeignKey,
+
+    // Loading states
+    isCreating: createRecordMutation.isPending,
+    isCreatingMultiple: createRecordsMutation.isPending,
+    isUpdating: updateRecordMutation.isPending,
+    isDeleting: deleteRecordsMutation.isPending,
+
+    // Actions - all using mutateAsync for consistency
+    createRecord: createRecordMutation.mutateAsync,
+    updateRecord: updateRecordMutation.mutateAsync,
+    deleteRecords: deleteRecordsMutation.mutateAsync,
+  };
+}

package/frontend/src/features/database/hooks/useTables.ts

@@ -0,0 +1,131 @@
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import { tableService } from '../services/table.service';
+import { useToast } from '@/lib/hooks/useToast';
+import {
+  ColumnSchema,
+  GetTableSchemaResponse,
+  UpdateTableSchemaRequest,
+} from '@insforge/shared-schemas';
+import { useMemo } from 'react';
+
+export function useTables() {
+  const queryClient = useQueryClient();
+  const { showToast } = useToast();
+
+  // Query to fetch all table names
+  const {
+    data: tables,
+    isLoading: isLoadingTables,
+    error: tablesError,
+    refetch: refetchTables,
+  } = useQuery({
+    queryKey: ['tables'],
+    queryFn: () => tableService.listTables(),
+    staleTime: 2 * 60 * 1000, // Cache for 2 minutes
+  });
+
+  // Query to fetch all table schemas
+  const {
+    data: allSchemas,
+    isLoading: isLoadingSchemas,
+    error: schemasError,
+    refetch: refetchAllSchemas,
+  } = useQuery({
+    queryKey: ['tables', 'schemas'],
+    queryFn: () => tableService.getAllTableSchemas(),
+    staleTime: 2 * 60 * 1000,
+  });
+
+  // Query to fetch a specific table schema
+  const useTableSchema = (tableName: string, enabled = true) => {
+    return useQuery({
+      queryKey: ['tables', tableName, 'schema'],
+      queryFn: () => tableService.getTableSchema(tableName),
+      enabled: enabled && !!tableName,
+      staleTime: 2 * 60 * 1000,
+    });
+  };
+
+  // Mutation to create a table
+  const createTableMutation = useMutation({
+    mutationFn: ({ tableName, columns }: { tableName: string; columns: ColumnSchema[] }) =>
+      tableService.createTable(tableName, columns),
+    onSuccess: () => {
+      void queryClient.invalidateQueries({ queryKey: ['tables'] });
+      void queryClient.invalidateQueries({ queryKey: ['tables', 'schemas'] });
+      showToast('Table created successfully', 'success');
+    },
+    onError: (error: Error) => {
+      const errorMessage = error instanceof Error ? error.message : 'Failed to create table';
+      showToast(errorMessage, 'error');
+    },
+  });
+
+  // Mutation to delete a table
+  const deleteTableMutation = useMutation({
+    mutationFn: (tableName: string) => tableService.deleteTable(tableName),
+    onSuccess: () => {
+      void queryClient.invalidateQueries({ queryKey: ['tables'] });
+      void queryClient.invalidateQueries({ queryKey: ['tables', 'schemas'] });
+      showToast('Table deleted successfully', 'success');
+    },
+    onError: (error: Error) => {
+      const errorMessage = error instanceof Error ? error.message : 'Failed to delete table';
+      showToast(errorMessage, 'error');
+    },
+  });
+
+  // Mutation to update table schema
+  const updateTableSchemaMutation = useMutation({
+    mutationFn: ({
+      tableName,
+      operations,
+    }: {
+      tableName: string;
+      operations: UpdateTableSchemaRequest;
+    }) => tableService.updateTableSchema(tableName, operations),
+    onSuccess: (_, { tableName }) => {
+      void queryClient.invalidateQueries({ queryKey: ['tables', 'schemas'] });
+      void queryClient.invalidateQueries({ queryKey: ['tables', tableName, 'schema'] });
+      showToast('Table schema updated successfully', 'success');
+    },
+    onError: (error: Error) => {
+      const errorMessage = error instanceof Error ? error.message : 'Failed to update table schema';
+      showToast(errorMessage, 'error');
+    },
+  });
+
+  return {
+    // Data
+    tables: tables || [],
+    allSchemas: useMemo(
+      () => allSchemas?.filter((schema) => schema.tableName !== 'users') || [],
+      [allSchemas]
+    ),
+    tablesCount: tables?.length || 0,
+
+    // Loading states
+    isLoadingTables,
+    isLoadingSchemas,
+    isCreating: createTableMutation.isPending,
+    isDeleting: deleteTableMutation.isPending,
+    isUpdating: updateTableSchemaMutation.isPending,
+
+    // Errors
+    tablesError,
+    schemasError,
+
+    // Actions
+    createTable: createTableMutation.mutate,
+    deleteTable: deleteTableMutation.mutate,
+    updateTableSchema: updateTableSchemaMutation.mutate,
+    refetchTables,
+    refetchAllSchemas,
+
+    // Helpers
+    useTableSchema,
+    getSchemaByTableName: (tableName: string): GetTableSchemaResponse | undefined => {
+      return allSchemas?.find((schema) => schema.tableName === tableName);
+    },
+  };
+}

package/frontend/src/features/database/index.ts

@@ -6,7 +6,12 @@ export { TableForm } from './components/TableForm';
 export { RecordFormDialog } from './components/RecordFormDialog';
 
 // Services
-export { databaseService } from './services/database.service';
+export { tableService } from './services/table.service';
+export { recordService } from './services/record.service';
+
+// Hooks
+export { useTables } from './hooks/useTables';
+export { useRecords } from './hooks/useRecords';
 
 // Helpers
 export { buildDynamicSchema, getInitialValues } from './helpers';