insforge 0.3.1

package/frontend/src/features/visualizer/page/VisualizerPage.tsx

@@ -0,0 +1,127 @@
+import { useQuery, useQueryClient } from '@tanstack/react-query';
+import { RefreshCw } from 'lucide-react';
+import { useCallback, useEffect } from 'react';
+import { useMetadata } from '@/features/metadata/hooks/useMetadata';
+import { authService } from '@/features/auth/services/auth.service';
+import { SchemaVisualizer, VisualizerSkeleton } from '../components';
+import { Button } from '@/components/radix/Button';
+import { Alert, AlertDescription } from '@/components/radix/Alert';
+import {
+  useSocket,
+  ServerEvents,
+  DataUpdatePayload,
+  DataUpdateResourceType,
+  SocketMessage,
+} from '@/lib/contexts/SocketContext';
+
+const VisualizerPage = () => {
+  const { socket, isConnected } = useSocket();
+  const queryClient = useQueryClient();
+
+  const {
+    metadata,
+    isLoading: metadataLoading,
+    error: metadataError,
+    refetch: refetchMetadata,
+  } = useMetadata();
+
+  const {
+    data: userStats,
+    isLoading: userStatsLoading,
+    refetch: refetchUserStats,
+  } = useQuery({
+    queryKey: ['user-stats-visualizer'],
+    queryFn: async () => {
+      const response = await authService.getUsers();
+      return { userCount: response.pagination.total };
+    },
+    staleTime: 5 * 60 * 1000,
+    gcTime: 10 * 60 * 1000,
+  });
+
+  const isLoading = metadataLoading || userStatsLoading;
+  const error = metadataError;
+
+  const handleRefresh = useCallback(() => {
+    void refetchMetadata();
+    void refetchUserStats();
+  }, [refetchMetadata, refetchUserStats]);
+
+  // Listen for schema change events
+  useEffect(() => {
+    if (!socket || !isConnected) {
+      return;
+    }
+
+    const handleDataUpdate = (message: SocketMessage<DataUpdatePayload>) => {
+      if (
+        message.payload?.resource === DataUpdateResourceType.METADATA ||
+        message.payload?.resource === DataUpdateResourceType.DATABASE_SCHEMA ||
+        message.payload?.resource === DataUpdateResourceType.TABLE_SCHEMA ||
+        message.payload?.resource === DataUpdateResourceType.OAUTH_SCHEMA ||
+        message.payload?.resource === DataUpdateResourceType.STORAGE_SCHEMA
+      ) {
+        // Invalidate all metadata-related queries
+        void queryClient.invalidateQueries({ queryKey: ['metadata'] });
+      }
+    };
+
+    socket.on(ServerEvents.DATA_UPDATE, handleDataUpdate);
+
+    return () => {
+      socket.off(ServerEvents.DATA_UPDATE, handleDataUpdate);
+    };
+  }, [socket, isConnected, queryClient]);
+
+  if (isLoading) {
+    return <VisualizerSkeleton />;
+  }
+
+  if (!metadata || error) {
+    return (
+      <div className="relative min-h-screen bg-neutral-800 overflow-hidden">
+        {/* Dot Matrix Background */}
+        <div
+          className="absolute inset-0 opacity-50"
+          style={{
+            backgroundImage: `radial-gradient(circle, #3B3B3B 1px, transparent 1px)`,
+            backgroundSize: '12px 12px',
+          }}
+        />
+
+        <div className="relative z-10 flex items-center justify-center min-h-screen p-8">
+          <Alert variant="destructive" className="max-w-md">
+            <AlertDescription>
+              Failed to load database schema. Please ensure the backend is running and try
+              refreshing.
+            </AlertDescription>
+            <Button onClick={handleRefresh} className="mt-4 w-full" variant="outline">
+              <RefreshCw className="w-4 h-4 mr-2" />
+              Retry
+            </Button>
+          </Alert>
+        </div>
+      </div>
+    );
+  }
+
+  return (
+    <div className="relative min-h-screen bg-neutral-800 overflow-hidden">
+      {/* Dot Matrix Background */}
+      <div
+        className="absolute inset-0 opacity-50"
+        style={{
+          backgroundImage: `radial-gradient(circle, #3B3B3B 1px, transparent 1px)`,
+          backgroundSize: '12px 12px',
+        }}
+      />
+
+      {/* Schema Visualizer */}
+      <div className="relative z-10 w-full h-screen">
+        <SchemaVisualizer metadata={metadata} userCount={userStats?.userCount} />
+      </div>
+    </div>
+  );
+};
+
+export default VisualizerPage;

package/frontend/src/index.css

@@ -0,0 +1,248 @@
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap');
+@import 'tailwindcss';
+@config "../tailwind.config.js";
+
+@layer utilities {
+  /* PocketBase-inspired Design Tokens */
+  :root {
+    /* Colors */
+    --pb-primary: #1a1a24;
+    --pb-text-primary: #1a1a24;
+    --pb-text-hint: #617079;
+    --pb-text-disabled: #a0a6ac;
+
+    --pb-body: #f8f9fa;
+    --pb-base: #ffffff;
+    --pb-base-alt1: #e3e8ed;
+    --pb-base-alt2: #d7dde3;
+    --pb-base-alt3: #c9d0da;
+    --pb-base-alt4: #a5b0c0;
+
+    --pb-info: #5499e8;
+    --pb-success: #32ad84;
+    --pb-danger: #e34562;
+    --pb-warning: #ff944d;
+
+    /* Spacing */
+    --pb-spacing-xs: 15px;
+    --pb-spacing-sm: 20px;
+    --pb-spacing-base: 30px;
+    --pb-spacing-lg: 50px;
+    --pb-spacing-xl: 60px;
+
+    /* Animation */
+    --pb-animation-base: 150ms;
+    --pb-animation-active: 70ms;
+    --pb-animation-entrance: 250ms;
+  }
+}
+
+@layer base {
+  :root {
+    /* Spacing system */
+    --baseSpacing: 2rem; /* 32px = 8 * 0.25rem */
+    --smSpacing: 1.25rem; /* 20px */
+    --xsSpacing: 1rem; /* 16px */
+
+    /* Font system */
+    --baseFontSize: 0.875rem; /* 14px */
+    --smFontSize: 0.8125rem; /* 13px */
+    --xsFontSize: 0.75rem; /* 12px */
+    --lgFontSize: 1.25rem; /* 20px */
+    --xlFontSize: 1.375rem; /* 22px */
+
+    /* Font weights */
+    --fontWeightNormal: 400;
+    --fontWeightMedium: 500;
+    --fontWeightSemibold: 600;
+
+    /* Font families */
+    --fontFamilyBase:
+      'Inter', system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+    --fontFamilyMono: 'Ubuntu Mono', ui-monospace, monospace;
+  }
+
+  /* Prevent document-level scrolling */
+  html,
+  body {
+    overflow: hidden;
+    height: 100%;
+  }
+
+  /* Apply base font settings */
+  body {
+    font-family: var(--fontFamilyBase);
+    font-size: var(--baseFontSize);
+    font-weight: var(--fontWeightNormal);
+  }
+
+  /* Typography scale */
+  h1 {
+    font-size: var(--xlFontSize);
+    font-weight: var(--fontWeightSemibold);
+    line-height: 1.3;
+  }
+
+  h2 {
+    font-size: var(--lgFontSize);
+    font-weight: var(--fontWeightSemibold);
+    line-height: 1.3;
+  }
+
+  .text-xs {
+    font-size: var(--xsFontSize);
+  }
+
+  .text-sm {
+    font-size: var(--smFontSize);
+  }
+
+  .font-mono {
+    font-family: var(--fontFamilyMono);
+  }
+}
+
+@layer components {
+  /* Checkbox styling */
+  input[type='checkbox'] {
+    @apply cursor-pointer;
+    accent-color: #000000;
+  }
+
+  input[type='checkbox']:checked {
+    background-color: #000000 !important;
+    border-color: #000000 !important;
+    accent-color: #000000;
+  }
+
+  input[type='checkbox']:checked:hover {
+    background-color: #1a1a1a !important;
+    border-color: #1a1a1a !important;
+  }
+
+  input[type='checkbox']:focus {
+    outline: none !important;
+    box-shadow: none !important;
+  }
+
+  input[type='checkbox']:focus-visible {
+    outline: none !important;
+    box-shadow: none !important;
+  }
+
+  button {
+    cursor: pointer;
+  }
+
+  input:focus {
+    outline: none !important;
+  }
+
+  button:focus {
+    outline: none !important;
+  }
+}
+
+@layer base {
+  /* CSS Variables for Radix UI components - using RGB values for clarity */
+  :root {
+    /* Light mode colors */
+    --background: 255 255 255; /* white */
+    --foreground: 10 10 10; /* near-black */
+    --card: 255 255 255; /* white */
+    --card-foreground: 10 10 10; /* near-black */
+    --popover: 255 255 255; /* white */
+    --popover-foreground: 10 10 10; /* near-black */
+    --primary: 23 23 23; /* zinc-900 */
+    --primary-foreground: 250 250 250; /* zinc-50 */
+    --secondary: 245 245 245; /* neutral-100 */
+    --secondary-foreground: 23 23 23; /* zinc-900 */
+    --muted: 245 245 245; /* neutral-100 */
+    --muted-foreground: 115 115 115; /* neutral-500 */
+    --accent: 245 245 245; /* neutral-100 */
+    --accent-foreground: 23 23 23; /* zinc-900 */
+    --destructive: 239 68 68; /* red-500 */
+    --destructive-foreground: 250 250 250; /* zinc-50 */
+    --border: 228 228 231; /* zinc-200 */
+    --input: 228 228 231; /* zinc-200 */
+    --ring: 10 10 10; /* near-black */
+    --radius: 0.5rem;
+    --background-color: #ffffff;
+    --border-color: #737373;
+    --border-hover-color: #d4d4d4;
+  }
+
+  .dark {
+    /* Dark mode colors - matching your neutral theme */
+    --background: 38 38 38; /* neutral-800 */
+    --foreground: 250 250 250; /* zinc-50 */
+    --card: 64 64 64; /* neutral-700 */
+    --card-foreground: 250 250 250; /* zinc-50 */
+    --popover: 64 64 64; /* neutral-700 */
+    --popover-foreground: 250 250 250; /* zinc-50 */
+    --primary: 250 250 250; /* zinc-50 */
+    --primary-foreground: 23 23 23; /* zinc-900 */
+    --secondary: 82 82 82; /* neutral-600 */
+    --secondary-foreground: 250 250 250; /* zinc-50 */
+    --muted: 82 82 82; /* neutral-600 */
+    --muted-foreground: 163 163 163; /* neutral-400 */
+    --accent: 82 82 82; /* neutral-600 */
+    --accent-foreground: 250 250 250; /* zinc-50 */
+    --destructive: 127 29 29; /* red-900 */
+    --destructive-foreground: 250 250 250; /* zinc-50 */
+    --border: 64 64 64; /* neutral-700 */
+    --input: 64 64 64; /* neutral-700 */
+    --ring: 212 212 212; /* zinc-300 */
+    --background-color: #262626;
+    --border-color: #737373;
+    --border-hover-color: #d4d4d4;
+  }
+}
+
+@layer base {
+  body {
+    font-family:
+      'Inter',
+      -apple-system,
+      BlinkMacSystemFont,
+      'Segoe UI',
+      Roboto,
+      'Helvetica Neue',
+      Arial,
+      sans-serif;
+  }
+}
+
+@theme {
+  --color-border-gray: #e4e4e7;
+  --color-chart-blue-dark: #2c7fff;
+  --color-text-gray: #a1a1a1;
+  --color-bg-gray: #f8f9fa;
+  --color-link-blue: #2c7fff;
+  --color-bg-gray-hover: #ebebeb;
+}
+
+/* Fix for Radix UI dropdowns to prevent scroll lock */
+[data-radix-popper-content-wrapper] {
+  position: fixed !important;
+}
+
+/* Custom scrollbar styles */
+::-webkit-scrollbar {
+  width: 10px;
+  height: 10px;
+}
+
+::-webkit-scrollbar-track {
+  background: var(--background-color);
+  border-radius: 5px;
+}
+
+::-webkit-scrollbar-thumb {
+  background: var(--border-color);
+  border-radius: 5px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+  background: var(--border-hover-color);
+}

package/frontend/src/lib/api/client.ts

@@ -0,0 +1,163 @@
+const API_BASE = '/api';
+
+interface ApiError extends Error {
+  response?: {
+    data: unknown;
+    status: number;
+  };
+}
+
+export class ApiClient {
+  private token: string | null = null;
+  private onAuthError?: () => void;
+
+  constructor() {
+    this.token = localStorage.getItem('insforge_token');
+  }
+
+  setToken(token: string) {
+    this.token = token;
+    localStorage.setItem('insforge_token', token);
+  }
+
+  clearToken() {
+    this.token = null;
+    localStorage.removeItem('insforge_token');
+  }
+
+  getToken() {
+    return this.token;
+  }
+
+  setAuthErrorHandler(handler?: () => void) {
+    this.onAuthError = handler;
+  }
+
+  request(
+    endpoint: string,
+    options: RequestInit & {
+      returnFullResponse?: boolean;
+      skipAuth?: boolean;
+    } = {}
+  ) {
+    const url = `${API_BASE}${endpoint}`;
+    const { returnFullResponse, skipAuth, ...fetchOptions } = options;
+
+    // Initial request attempt
+    const makeRequest = async () => {
+      // Merge headers properly to preserve Content-Type when body is present
+      const headers: Record<string, string> = {
+        ...(!skipAuth && this.token && { Authorization: `Bearer ${this.token}` }),
+        ...((fetchOptions.headers as Record<string, string>) || {}),
+      };
+
+      // Ensure Content-Type is set for JSON bodies
+      if (fetchOptions.body && typeof fetchOptions.body === 'string') {
+        headers['Content-Type'] = headers['Content-Type'] || 'application/json';
+      }
+
+      const config: RequestInit = {
+        ...fetchOptions,
+        headers,
+      };
+
+      const response = await fetch(url, config);
+
+      if (!response.ok) {
+        let errorData;
+        try {
+          errorData = await response.json();
+        } catch {
+          // If parsing JSON fails, throw a generic error
+          const error: ApiError = new Error(`HTTP ${response.status}: ${response.statusText}`);
+          error.response = { data: null, status: response.status };
+          throw error;
+        }
+
+        // Handle authentication errors
+        if (response.status === 401 && !skipAuth) {
+          // Clear token and notify auth context
+          this.clearToken();
+          if (this.onAuthError) {
+            this.onAuthError();
+          }
+        }
+
+        // Handle traditional REST error format
+        if (errorData.error && errorData.message) {
+          const error: ApiError = new Error(errorData.message);
+          error.response = {
+            data: errorData,
+            status: response.status,
+          };
+          throw error;
+        }
+
+        // Fallback for other error formats
+        const error: ApiError = new Error(`HTTP ${response.status}: ${JSON.stringify(errorData)}`);
+        error.response = {
+          data: errorData,
+          status: response.status,
+        };
+        throw error;
+      }
+      const text = await response.text();
+      // compatible with empty response
+      let responseData = null;
+      try {
+        responseData = text ? JSON.parse(text) : null;
+      } catch {
+        responseData = text;
+      }
+
+      // Check for Content-Range header and extract pagination if present
+      const contentRange = response.headers.get('content-range');
+      if (contentRange && Array.isArray(responseData)) {
+        const match = contentRange.match(/(\d+)-(\d+)\/(\d+|\*)/);
+        if (match) {
+          const start = parseInt(match[1]);
+          const end = parseInt(match[2]);
+          const total = match[3] === '*' ? responseData.length : parseInt(match[3]);
+
+          const pagination = {
+            offset: start,
+            limit: end - start + 1,
+            total,
+          };
+
+          return {
+            data: responseData,
+            pagination,
+          };
+        } else {
+          return {
+            data: responseData,
+            pagination: {
+              offset: 0,
+              limit: 0,
+              total: 0,
+            },
+          };
+        }
+      }
+
+      // If full response is requested, return it as-is
+      if (returnFullResponse) {
+        return responseData;
+      }
+
+      // Traditional REST format - return response directly
+      return responseData;
+    };
+
+    return makeRequest();
+  }
+
+  // Helper method to add authorization header with token
+  withAccessToken(headers: Record<string, string> = {}) {
+    return this.token ? { ...headers, Authorization: `Bearer ${this.token}` } : headers;
+  }
+}
+
+// Singleton instance
+export const apiClient = new ApiClient();

package/frontend/src/lib/contexts/AuthContext.tsx

@@ -0,0 +1,157 @@
+import React, { createContext, useContext, useState, useEffect, useCallback } from 'react';
+import { useQueryClient } from '@tanstack/react-query';
+import { authService } from '@/features/auth/services/auth.service';
+import { apiClient } from '@/lib/api/client';
+
+export interface User {
+  id: string;
+  email: string;
+  name?: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+interface AuthContextType {
+  user: User | null;
+  isAuthenticated: boolean;
+  isLoading: boolean;
+  loginWithPassword: (email: string, password: string) => Promise<boolean>;
+  loginWithAuthorizationCode: (token: string) => Promise<boolean>;
+  logout: () => void;
+  refreshAuth: () => Promise<void>;
+  error: Error | null;
+}
+
+const AuthContext = createContext<AuthContextType | undefined>(undefined);
+
+export const useAuth = () => {
+  const context = useContext(AuthContext);
+  if (!context) {
+    throw new Error('useAuth must be used within an AuthProvider');
+  }
+  return context;
+};
+
+interface AuthProviderProps {
+  children: React.ReactNode;
+}
+
+export const AuthProvider: React.FC<AuthProviderProps> = ({ children }) => {
+  const [user, setUser] = useState<User | null>(null);
+  const [isAuthenticated, setIsAuthenticated] = useState<boolean>(false);
+  const [isLoading, setIsLoading] = useState<boolean>(true);
+  const [error, setError] = useState<Error | null>(null);
+  const queryClient = useQueryClient();
+
+  const handleAuthError = useCallback(() => {
+    setUser(null);
+    setIsAuthenticated(false);
+  }, []);
+
+  // Set up auth error handler
+  useEffect(() => {
+    apiClient.setAuthErrorHandler(handleAuthError);
+    return () => {
+      apiClient.setAuthErrorHandler(undefined);
+    };
+  }, [handleAuthError]);
+
+  const checkAuthStatus = useCallback(async () => {
+    try {
+      setIsLoading(true);
+      setError(null);
+      const currentUser = await authService.getCurrentUser();
+      setUser(currentUser);
+      setIsAuthenticated(true);
+      return currentUser;
+    } catch (err) {
+      setUser(null);
+      setIsAuthenticated(false);
+      if (err instanceof Error && !err.message.includes('401')) {
+        setError(err);
+      }
+      apiClient.clearToken();
+      return null;
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+
+  const loginWithPassword = useCallback(
+    async (email: string, password: string): Promise<boolean> => {
+      try {
+        setError(null);
+        await authService.loginWithPassword(email, password);
+        const currentUser = await checkAuthStatus();
+        if (currentUser) {
+          // Invalidate queries that depend on authentication
+          void queryClient.invalidateQueries({ queryKey: ['apiKey'] });
+          void queryClient.invalidateQueries({ queryKey: ['metadata'] });
+          void queryClient.invalidateQueries({ queryKey: ['users'] });
+          void queryClient.invalidateQueries({ queryKey: ['tables'] });
+          return true;
+        }
+        return false;
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error('Login failed'));
+        return false;
+      }
+    },
+    [checkAuthStatus, queryClient]
+  );
+
+  const loginWithAuthorizationCode = useCallback(
+    async (token: string): Promise<boolean> => {
+      try {
+        setError(null);
+        await authService.loginWithAuthorizationCode(token);
+        const currentUser = await checkAuthStatus();
+        if (currentUser) {
+          // Invalidate queries that depend on authentication
+          void queryClient.invalidateQueries({ queryKey: ['apiKey'] });
+          void queryClient.invalidateQueries({ queryKey: ['metadata'] });
+          void queryClient.invalidateQueries({ queryKey: ['users'] });
+          void queryClient.invalidateQueries({ queryKey: ['tables'] });
+          return true;
+        }
+        return false;
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error('Authorization code exchange failed'));
+        return false;
+      }
+    },
+    [checkAuthStatus, queryClient]
+  );
+
+  const logout = useCallback(() => {
+    void authService.logout();
+    setUser(null);
+    setIsAuthenticated(false);
+    setError(null);
+  }, []);
+
+  const refreshAuth = useCallback(async () => {
+    await checkAuthStatus();
+  }, [checkAuthStatus]);
+
+  // Check auth status on mount
+  useEffect(() => {
+    void checkAuthStatus();
+  }, [checkAuthStatus]);
+
+  // Removed periodic auth refresh - it was causing unnecessary unmounts
+  // Auth status is checked naturally when API calls are made
+
+  const value: AuthContextType = {
+    user,
+    isAuthenticated,
+    isLoading,
+    loginWithPassword,
+    loginWithAuthorizationCode,
+    logout,
+    refreshAuth,
+    error,
+  };
+
+  return <AuthContext.Provider value={value}>{children}</AuthContext.Provider>;
+};