@robosystems/core 0.3.0

package/auth-components/index.js

@@ -0,0 +1,6 @@
+export { AppSwitcher } from './AppSwitcher';
+export { AuthGuard } from './AuthGuard';
+export { AuthProvider, useAuth } from './AuthProvider';
+export { SignInForm } from './SignInForm';
+export { SignUpForm } from './SignUpForm';
+export { TurnstileWidget, useTurnstile } from './TurnstileWidget';

package/auth-core/cleanup.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Logout cleanup utilities
+ *
+ * Provides comprehensive cleanup of user-specific data on logout
+ * including cookies, localStorage, and sessionStorage.
+ */
+/**
+ * Clear all user-specific cookies on logout
+ */
+export declare function clearUserCookies(): void;
+/**
+ * Clear user-specific localStorage items
+ */
+export declare function clearUserLocalStorage(): void;
+/**
+ * Clear user-specific sessionStorage items
+ */
+export declare function clearUserSessionStorage(): void;
+/**
+ * Comprehensive logout cleanup
+ *
+ * Clears all user-specific data from the browser including:
+ * - User-specific cookies (graph selection, preferences, etc.)
+ * - User-specific localStorage items (saved queries, etc.)
+ * - User-specific sessionStorage items (auth cache, etc.)
+ */
+export declare function performLogoutCleanup(): void;
+/**
+ * Reset UI state that should not persist between users
+ *
+ * This can be called to reset UI state that might confuse
+ * users when switching accounts (like showing graph tabs
+ * for a user who doesn't have any graphs).
+ */
+export declare function resetUIState(): void;
+/**
+ * Diagnostic function to list all cookies and storage items
+ * Useful for development and debugging
+ */
+export declare function listUserData(): {
+    cookies: string[];
+    localStorage: string[];
+    sessionStorage: string[];
+};

package/auth-core/cleanup.js

@@ -0,0 +1,157 @@
+/**
+ * Logout cleanup utilities
+ *
+ * Provides comprehensive cleanup of user-specific data on logout
+ * including cookies, localStorage, and sessionStorage.
+ */
+/**
+ * Clear all user-specific cookies on logout
+ */
+export function clearUserCookies() {
+    if (typeof document === 'undefined')
+        return;
+    // List of user-specific cookies to clear
+    const userCookies = [
+        'selected-graph', // Graph selection state
+        'selected-entity', // Entity selection state
+        'credit-visibility', // UI preferences
+        // Note: auth-token is cleared by the backend
+        // Note: sidebar-collapsed is kept as it's a UI preference that can persist
+    ];
+    userCookies.forEach((cookieName) => {
+        // Set cookie to expired date to delete it
+        document.cookie = `${cookieName}=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/; domain=${window.location.hostname}`;
+        // Also try without domain for localhost/development
+        document.cookie = `${cookieName}=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/`;
+    });
+}
+/**
+ * Clear user-specific localStorage items
+ */
+export function clearUserLocalStorage() {
+    if (typeof localStorage === 'undefined')
+        return;
+    try {
+        // Get all localStorage keys
+        const keys = Object.keys(localStorage);
+        // Patterns of user-specific localStorage items to clear
+        const userDataPatterns = [
+            /^saved_queries_/, // Saved queries per graph: saved_queries_${graphId}
+            /^query_history_/, // Query history per graph: query_history_${graphId}
+            /^graph_/, // Any graph-specific data
+            /^user_/, // Any user-specific data
+            /^auth_/, // Auth-related data (though we handle auth_user_cache separately)
+        ];
+        // Clear matching items
+        keys.forEach((key) => {
+            if (userDataPatterns.some((pattern) => pattern.test(key))) {
+                try {
+                    localStorage.removeItem(key);
+                }
+                catch (error) {
+                    console.warn(`Failed to remove localStorage item: ${key}`, error);
+                }
+            }
+        });
+    }
+    catch (error) {
+        console.warn('Failed to access localStorage for cleanup', error);
+    }
+}
+/**
+ * Clear user-specific sessionStorage items
+ */
+export function clearUserSessionStorage() {
+    if (typeof sessionStorage === 'undefined')
+        return;
+    try {
+        // Get all sessionStorage keys
+        const keys = Object.keys(sessionStorage);
+        // Patterns of user-specific sessionStorage items to clear
+        const userDataPatterns = [
+            /^auth_/, // Auth cache and related data
+            /^user_/, // User-specific session data
+            /^graph_/, // Graph-specific session data
+            /^temp_/, // Temporary user data
+        ];
+        // Clear matching items
+        keys.forEach((key) => {
+            if (userDataPatterns.some((pattern) => pattern.test(key))) {
+                try {
+                    sessionStorage.removeItem(key);
+                }
+                catch (error) {
+                    console.warn(`Failed to remove sessionStorage item: ${key}`, error);
+                }
+            }
+        });
+    }
+    catch (error) {
+        console.warn('Failed to access sessionStorage for cleanup', error);
+    }
+}
+/**
+ * Comprehensive logout cleanup
+ *
+ * Clears all user-specific data from the browser including:
+ * - User-specific cookies (graph selection, preferences, etc.)
+ * - User-specific localStorage items (saved queries, etc.)
+ * - User-specific sessionStorage items (auth cache, etc.)
+ */
+export function performLogoutCleanup() {
+    clearUserCookies();
+    clearUserLocalStorage();
+    clearUserSessionStorage();
+}
+/**
+ * Reset UI state that should not persist between users
+ *
+ * This can be called to reset UI state that might confuse
+ * users when switching accounts (like showing graph tabs
+ * for a user who doesn't have any graphs).
+ */
+export function resetUIState() {
+    if (typeof document === 'undefined')
+        return;
+    // Clear selected graph cookie specifically
+    document.cookie = `selected-graph=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/`;
+    // You could also reset other UI state here, but be careful
+    // not to clear preferences that should persist (like theme, language, etc.)
+}
+/**
+ * Diagnostic function to list all cookies and storage items
+ * Useful for development and debugging
+ */
+export function listUserData() {
+    const result = {
+        cookies: [],
+        localStorage: [],
+        sessionStorage: [],
+    };
+    // List cookies
+    if (typeof document !== 'undefined') {
+        result.cookies = document.cookie
+            .split(';')
+            .map((c) => c.trim().split('=')[0])
+            .filter(Boolean);
+    }
+    // List localStorage
+    if (typeof localStorage !== 'undefined') {
+        try {
+            result.localStorage = Object.keys(localStorage);
+        }
+        catch (error) {
+            console.warn('Failed to access localStorage', error);
+        }
+    }
+    // List sessionStorage
+    if (typeof sessionStorage !== 'undefined') {
+        try {
+            result.sessionStorage = Object.keys(sessionStorage);
+        }
+        catch (error) {
+            console.warn('Failed to access sessionStorage', error);
+        }
+    }
+    return result;
+}

package/auth-core/client.d.ts

@@ -0,0 +1,121 @@
+import type { APIKey, AuthResponse, AuthUser, CreateAPIKeyRequest, SSOTokenResponse } from './types';
+export declare class TokenExpiredError extends Error {
+    constructor(message?: string);
+}
+export declare class RoboSystemsAuthClient {
+    private client;
+    private authCheckPromise;
+    private lastAuthCheck;
+    private lastError;
+    private refreshRetryCount;
+    private readonly MAX_REFRESH_RETRIES;
+    private readonly INITIAL_RETRY_DELAY;
+    constructor(baseUrl: string);
+    /**
+     * Configure the client with JWT authentication for all requests
+     */
+    private configureClientWithAuth;
+    /**
+     * Push the latest auth token into the SDK extensions global config.
+     *
+     * Called from every auth success path (`login` / `register` / SSO
+     * token exchange / verify-email) so the SDK extensions singleton
+     * stays in sync with the current credential.
+     *
+     * The GraphQL read path already has refresh via `tokenProvider`
+     * (wired in `configureClientWithAuth`) and does not depend on this
+     * static field. But the SDK's React hooks (`useQuery`, `useOperation`,
+     * `useStreamingQuery`, …) still read `getSDKClientConfig().token`
+     * via `extractTokenFromSDKClient` to seed their inner `QueryClient`
+     * / `OperationClient` instances. Keeping the static field updated
+     * after every auth success keeps those hook-owned clients
+     * authenticated across login/register/SSO transitions.
+     *
+     * No-op when the SDK extensions module isn't installed.
+     */
+    private syncClientConfigToken;
+    login(email: string, password: string): Promise<AuthResponse>;
+    register(email: string, password: string, name?: string, captchaToken?: string): Promise<AuthResponse>;
+    logout(): Promise<void>;
+    getCurrentUser(): Promise<AuthUser>;
+    private performAuthCheck;
+    refreshSession(): Promise<AuthResponse>;
+    /**
+     * Refresh session with exponential backoff retry logic
+     */
+    private refreshSessionWithRetry;
+    createAPIKey(request: CreateAPIKeyRequest): Promise<APIKey>;
+    getAPIKeys(): Promise<APIKey[]>;
+    revokeAPIKey(keyId: string): Promise<void>;
+    generateSSOToken(): Promise<SSOTokenResponse>;
+    ssoExchange(token: string, targetApp: string): Promise<{
+        session_id: string;
+    }>;
+    ssoComplete(sessionId: string): Promise<AuthResponse>;
+    checkAuthentication(): Promise<AuthUser | null>;
+    clearAuthCache(): void;
+    /**
+     * Send password reset email
+     */
+    forgotPassword(email: string): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+    /**
+     * Reset password using token
+     */
+    resetPassword(token: string, newPassword: string): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+    /**
+     * Validate password reset token
+     */
+    validateResetToken(token: string): Promise<{
+        valid: boolean;
+        email?: string;
+        message?: string;
+    }>;
+    /**
+     * Verify email with token
+     */
+    verifyEmail(token: string): Promise<{
+        success: boolean;
+        message?: string;
+        user?: AuthUser;
+    }>;
+    /**
+     * Resend verification email
+     */
+    resendVerificationEmail(email: string): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+    /**
+     * Get password policy requirements
+     */
+    getPasswordPolicy(): Promise<{
+        minLength: number;
+        requireUppercase: boolean;
+        requireLowercase: boolean;
+        requireNumbers: boolean;
+        requireSpecial: boolean;
+        specialCharacters: string;
+    }>;
+    /**
+     * Check password strength
+     */
+    checkPasswordStrength(password: string, email?: string): Promise<{
+        score: number;
+        strength: 'very-weak' | 'weak' | 'fair' | 'good' | 'strong';
+        errors: string[];
+        suggestions: string[];
+        is_valid: boolean;
+    }>;
+    /**
+     * Validate and safely cast SDK response data
+     */
+    private normalizeUser;
+    private validateSDKAuthResponse;
+    private validateSDKCurrentUserResponse;
+}