@oxyhq/auth 1.0.0

package/dist/cjs/utils/storageHelpers.js

@@ -0,0 +1,147 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStorageKeys = exports.STORAGE_KEY_PREFIX = exports.createPlatformStorage = exports.isReactNative = void 0;
+/**
+ * Create an in-memory storage implementation used as a safe fallback.
+ */
+const MEMORY_STORAGE = () => {
+    const store = new Map();
+    return {
+        async getItem(key) {
+            return store.has(key) ? store.get(key) : null;
+        },
+        async setItem(key, value) {
+            store.set(key, value);
+        },
+        async removeItem(key) {
+            store.delete(key);
+        },
+        async clear() {
+            store.clear();
+        },
+    };
+};
+/**
+ * Create a web storage implementation backed by `localStorage`.
+ * Falls back to in-memory storage when unavailable.
+ */
+const createWebStorage = () => {
+    if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') {
+        return MEMORY_STORAGE();
+    }
+    return {
+        async getItem(key) {
+            try {
+                return window.localStorage.getItem(key);
+            }
+            catch {
+                return null;
+            }
+        },
+        async setItem(key, value) {
+            try {
+                window.localStorage.setItem(key, value);
+            }
+            catch {
+                // Ignore quota or access issues for now.
+            }
+        },
+        async removeItem(key) {
+            try {
+                window.localStorage.removeItem(key);
+            }
+            catch {
+                // Ignore failures.
+            }
+        },
+        async clear() {
+            try {
+                window.localStorage.clear();
+            }
+            catch {
+                // Ignore failures.
+            }
+        },
+    };
+};
+let asyncStorageInstance = null;
+/**
+ * Lazily import React Native AsyncStorage implementation.
+ */
+const createNativeStorage = async () => {
+    if (asyncStorageInstance) {
+        return asyncStorageInstance;
+    }
+    try {
+        const asyncStorageModule = await Promise.resolve().then(() => __importStar(require('@react-native-async-storage/async-storage')));
+        asyncStorageInstance = asyncStorageModule.default;
+        return asyncStorageInstance;
+    }
+    catch (error) {
+        if (__DEV__) {
+            console.error('Failed to import AsyncStorage:', error);
+        }
+        throw new Error('AsyncStorage is required in React Native environment');
+    }
+};
+/**
+ * Detect whether the current runtime is React Native.
+ */
+const isReactNative = () => typeof navigator !== 'undefined' && navigator.product === 'ReactNative';
+exports.isReactNative = isReactNative;
+/**
+ * Create a platform-appropriate storage implementation.
+ * Defaults to in-memory storage when no platform storage is available.
+ */
+const createPlatformStorage = async () => {
+    if ((0, exports.isReactNative)()) {
+        return createNativeStorage();
+    }
+    return createWebStorage();
+};
+exports.createPlatformStorage = createPlatformStorage;
+exports.STORAGE_KEY_PREFIX = 'oxy_session';
+/**
+ * Produce strongly typed storage key names for the supplied prefix.
+ *
+ * @param prefix - Storage key prefix
+ */
+const getStorageKeys = (prefix = exports.STORAGE_KEY_PREFIX) => ({
+    activeSessionId: `${prefix}_active_session_id`,
+    sessionIds: `${prefix}_session_ids`,
+    language: `${prefix}_language`,
+});
+exports.getStorageKeys = getStorageKeys;

package/dist/esm/WebOxyProvider.js

@@ -0,0 +1,282 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * @oxyhq/auth — Web Authentication Provider
+ *
+ * Clean implementation with ZERO React Native dependencies.
+ * Provides FedCM, popup, and redirect authentication methods.
+ * Uses centralized AuthManager for token and session management.
+ */
+import { createContext, useCallback, useContext, useEffect, useMemo, useState, } from 'react';
+import { OxyServices, CrossDomainAuth, createAuthManager, } from '@oxyhq/core';
+import { QueryClientProvider } from '@tanstack/react-query';
+import { createQueryClient } from './hooks/queryClient';
+const WebOxyContext = createContext(null);
+/**
+ * Web-only Oxy Provider
+ *
+ * Provides authentication context for pure web applications (React, Next.js, Vite).
+ * Supports FedCM, popup, and redirect authentication methods.
+ *
+ * @example
+ * ```tsx
+ * import { WebOxyProvider, useAuth } from '@oxyhq/auth';
+ *
+ * function App() {
+ *   return (
+ *     <WebOxyProvider baseURL="https://api.oxy.so">
+ *       <YourApp />
+ *     </WebOxyProvider>
+ *   );
+ * }
+ * ```
+ */
+export function WebOxyProvider({ children, baseURL, authWebUrl, onAuthStateChange, onError, preferredAuthMethod = 'auto', skipAutoCheck = false, }) {
+    const [oxyServices] = useState(() => new OxyServices({ baseURL, authWebUrl }));
+    const [crossDomainAuth] = useState(() => new CrossDomainAuth(oxyServices));
+    const [authManager] = useState(() => createAuthManager(oxyServices, { autoRefresh: true }));
+    const [queryClient] = useState(() => createQueryClient());
+    // Auth state
+    const [user, setUser] = useState(null);
+    const [isLoading, setIsLoading] = useState(!skipAutoCheck);
+    const [error, setError] = useState(null);
+    const [activeSessionId, setActiveSessionId] = useState(null);
+    const [sessions, setSessions] = useState([]);
+    const isAuthenticated = !!user;
+    const handleAuthSuccess = useCallback(async (session, method = 'credentials') => {
+        await authManager.handleAuthSuccess(session, method);
+        // Set active session
+        if (session.sessionId) {
+            setActiveSessionId(session.sessionId);
+        }
+        // Fetch full user profile
+        try {
+            const fullUser = await oxyServices.getCurrentUser();
+            if (fullUser) {
+                setUser(fullUser);
+            }
+            else {
+                setUser(session.user);
+            }
+        }
+        catch {
+            setUser(session.user);
+        }
+        setError(null);
+        setIsLoading(false);
+    }, [authManager, oxyServices]);
+    const handleAuthError = useCallback((err) => {
+        const errorMessage = err instanceof Error ? err.message : 'Authentication failed';
+        setError(errorMessage);
+        setIsLoading(false);
+        onError?.(err instanceof Error ? err : new Error(errorMessage));
+    }, [onError]);
+    // Initialize
+    useEffect(() => {
+        if (skipAutoCheck)
+            return;
+        let mounted = true;
+        const initAuth = async () => {
+            try {
+                const callbackSession = crossDomainAuth.handleRedirectCallback();
+                if (callbackSession && mounted) {
+                    await handleAuthSuccess(callbackSession, 'redirect');
+                    return;
+                }
+                const restoredUser = await authManager.initialize();
+                if (restoredUser && mounted) {
+                    try {
+                        const currentUser = await oxyServices.getCurrentUser();
+                        if (mounted && currentUser) {
+                            setUser(currentUser);
+                            setIsLoading(false);
+                            return;
+                        }
+                    }
+                    catch {
+                        await authManager.signOut();
+                    }
+                }
+                try {
+                    const session = await crossDomainAuth.silentSignIn();
+                    if (mounted && session?.user) {
+                        await handleAuthSuccess(session, 'fedcm');
+                        return;
+                    }
+                }
+                catch {
+                    // Silent sign-in failed
+                }
+                if (mounted)
+                    setIsLoading(false);
+            }
+            catch {
+                if (mounted)
+                    setIsLoading(false);
+            }
+        };
+        initAuth();
+        return () => { mounted = false; };
+    }, [oxyServices, crossDomainAuth, authManager, skipAutoCheck, handleAuthSuccess]);
+    useEffect(() => {
+        onAuthStateChange?.(user);
+    }, [user, onAuthStateChange]);
+    const signIn = useCallback(async () => {
+        setError(null);
+        setIsLoading(true);
+        let selectedMethod = 'popup';
+        try {
+            const session = await crossDomainAuth.signIn({
+                method: preferredAuthMethod,
+                onMethodSelected: (method) => {
+                    selectedMethod = method;
+                },
+            });
+            if (session) {
+                await handleAuthSuccess(session, selectedMethod);
+            }
+            else {
+                setIsLoading(false);
+            }
+        }
+        catch (err) {
+            handleAuthError(err);
+        }
+    }, [crossDomainAuth, preferredAuthMethod, handleAuthSuccess, handleAuthError]);
+    const signInWithFedCM = useCallback(async () => {
+        setError(null);
+        setIsLoading(true);
+        try {
+            const session = await crossDomainAuth.signInWithFedCM();
+            await handleAuthSuccess(session, 'fedcm');
+        }
+        catch (err) {
+            handleAuthError(err);
+        }
+    }, [crossDomainAuth, handleAuthSuccess, handleAuthError]);
+    const signInWithPopup = useCallback(async () => {
+        setError(null);
+        setIsLoading(true);
+        try {
+            const session = await crossDomainAuth.signInWithPopup();
+            await handleAuthSuccess(session, 'popup');
+        }
+        catch (err) {
+            handleAuthError(err);
+        }
+    }, [crossDomainAuth, handleAuthSuccess, handleAuthError]);
+    const signInWithRedirect = useCallback(() => {
+        setError(null);
+        crossDomainAuth.signInWithRedirect({
+            redirectUri: typeof window !== 'undefined' ? window.location.href : undefined,
+        });
+    }, [crossDomainAuth]);
+    const isFedCMSupported = useCallback(() => {
+        return crossDomainAuth.isFedCMSupported();
+    }, [crossDomainAuth]);
+    const signOut = useCallback(async () => {
+        setError(null);
+        try {
+            await authManager.signOut();
+            setUser(null);
+            setActiveSessionId(null);
+            setSessions([]);
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : 'Sign out failed';
+            setError(errorMessage);
+            onError?.(err instanceof Error ? err : new Error(errorMessage));
+        }
+    }, [authManager, onError]);
+    const switchSession = useCallback(async (sessionId) => {
+        try {
+            const result = await oxyServices.getTokenBySession(sessionId);
+            if (result) {
+                setActiveSessionId(sessionId);
+                const currentUser = await oxyServices.getCurrentUser();
+                if (currentUser)
+                    setUser(currentUser);
+            }
+        }
+        catch (err) {
+            handleAuthError(err);
+        }
+    }, [oxyServices, handleAuthError]);
+    const clearSessionState = useCallback(async () => {
+        await authManager.signOut();
+        setUser(null);
+        setActiveSessionId(null);
+        setSessions([]);
+    }, [authManager]);
+    useEffect(() => {
+        return () => { authManager.destroy(); };
+    }, [authManager]);
+    const contextValue = useMemo(() => ({
+        user,
+        isAuthenticated,
+        isLoading,
+        error,
+        activeSessionId,
+        sessions,
+        oxyServices,
+        crossDomainAuth,
+        authManager,
+        signIn,
+        signInWithFedCM,
+        signInWithPopup,
+        signInWithRedirect,
+        signOut,
+        isFedCMSupported,
+        switchSession,
+        clearSessionState,
+    }), [
+        user, isAuthenticated, isLoading, error, activeSessionId, sessions,
+        oxyServices, crossDomainAuth, authManager,
+        signIn, signInWithFedCM, signInWithPopup, signInWithRedirect,
+        signOut, isFedCMSupported, switchSession, clearSessionState,
+    ]);
+    return (_jsx(QueryClientProvider, { client: queryClient, children: _jsx(WebOxyContext.Provider, { value: contextValue, children: children }) }));
+}
+/**
+ * Hook to access the full Web Oxy context.
+ */
+export function useWebOxy() {
+    const context = useContext(WebOxyContext);
+    if (!context) {
+        throw new Error('useWebOxy must be used within WebOxyProvider');
+    }
+    return context;
+}
+/**
+ * Hook for authentication in web apps.
+ *
+ * @example
+ * ```tsx
+ * function LoginPage() {
+ *   const { user, isAuthenticated, signIn, signOut } = useAuth();
+ *   if (!isAuthenticated) return <button onClick={signIn}>Sign in</button>;
+ *   return <button onClick={signOut}>Sign out</button>;
+ * }
+ * ```
+ */
+export function useAuth() {
+    const ctx = useWebOxy();
+    return {
+        user: ctx.user,
+        isAuthenticated: ctx.isAuthenticated,
+        isLoading: ctx.isLoading,
+        isReady: !ctx.isLoading,
+        error: ctx.error,
+        activeSessionId: ctx.activeSessionId,
+        sessions: ctx.sessions,
+        signIn: ctx.signIn,
+        signInWithFedCM: ctx.signInWithFedCM,
+        signInWithPopup: ctx.signInWithPopup,
+        signInWithRedirect: ctx.signInWithRedirect,
+        signOut: ctx.signOut,
+        isFedCMSupported: ctx.isFedCMSupported,
+        switchSession: ctx.switchSession,
+        oxyServices: ctx.oxyServices,
+        authManager: ctx.authManager,
+    };
+}
+export default WebOxyProvider;

package/dist/esm/hooks/mutations/index.js

@@ -0,0 +1,10 @@
+/**
+ * Mutation Hooks
+ *
+ * TanStack Query mutation hooks for updating Oxy services data.
+ * All mutations handle authentication, error handling, and query invalidation.
+ */
+// Account mutation hooks
+export { useUpdateProfile, useUploadAvatar, useUpdateAccountSettings, useUpdatePrivacySettings, useUploadFile, } from './useAccountMutations';
+// Service mutation hooks (sessions, devices)
+export { useSwitchSession, useLogoutSession, useLogoutAll, useUpdateDeviceName, useRemoveDevice, } from './useServicesMutations';

package/dist/esm/hooks/mutations/mutationFactory.js

@@ -0,0 +1,122 @@
+/**
+ * Mutation Factory - Creates standardized mutations with optimistic updates
+ *
+ * This factory reduces boilerplate code for mutations that follow the common pattern:
+ * 1. Cancel outgoing queries
+ * 2. Snapshot previous data
+ * 3. Apply optimistic update
+ * 4. On error: rollback and show toast
+ * 5. On success: update cache, stores, and invalidate queries
+ */
+import { queryKeys, invalidateAccountQueries, invalidateUserQueries } from '../queries/queryKeys';
+import { toast } from 'sonner';
+import { useAuthStore } from '../../stores/authStore';
+/**
+ * Creates a standard profile mutation with optimistic updates
+ *
+ * @example
+ * ```ts
+ * const updateProfile = createProfileMutation({
+ *   mutationFn: (updates) => oxyServices.updateProfile(updates),
+ *   optimisticUpdate: (user, updates) => updates,
+ *   errorMessage: 'Failed to update profile',
+ * });
+ * ```
+ */
+export function createProfileMutation(config, queryClient, activeSessionId) {
+    const { mutationFn, cancelQueryKeys = [], optimisticUpdate, errorMessage = 'Operation failed', successMessage, updateAuthStore = true, invalidateUserQueries: shouldInvalidateUserQueries = true, invalidateAccountQueries: shouldInvalidateAccountQueries = true, onSuccess: customOnSuccess, } = config;
+    return {
+        mutationFn,
+        onMutate: async (variables) => {
+            // Cancel queries that might conflict
+            await queryClient.cancelQueries({ queryKey: queryKeys.accounts.current() });
+            for (const key of cancelQueryKeys) {
+                await queryClient.cancelQueries({ queryKey: key });
+            }
+            // Snapshot previous user data
+            const previousUser = queryClient.getQueryData(queryKeys.accounts.current());
+            // Apply optimistic update if provided
+            if (previousUser && optimisticUpdate) {
+                const updates = optimisticUpdate(previousUser, variables);
+                const optimisticUser = { ...previousUser, ...updates };
+                queryClient.setQueryData(queryKeys.accounts.current(), optimisticUser);
+                if (activeSessionId) {
+                    queryClient.setQueryData(queryKeys.users.profile(activeSessionId), optimisticUser);
+                }
+            }
+            return { previousUser };
+        },
+        onError: (error, _variables, context) => {
+            // Rollback optimistic update
+            if (context?.previousUser) {
+                queryClient.setQueryData(queryKeys.accounts.current(), context.previousUser);
+                if (activeSessionId) {
+                    queryClient.setQueryData(queryKeys.users.profile(activeSessionId), context.previousUser);
+                }
+            }
+            // Show error toast
+            const message = typeof errorMessage === 'function'
+                ? errorMessage(error)
+                : (error instanceof Error ? error.message : errorMessage);
+            toast.error(message);
+        },
+        onSuccess: (data, variables) => {
+            // Update cache with server response
+            queryClient.setQueryData(queryKeys.accounts.current(), data);
+            if (activeSessionId) {
+                queryClient.setQueryData(queryKeys.users.profile(activeSessionId), data);
+            }
+            // Update authStore for immediate UI updates
+            if (updateAuthStore) {
+                useAuthStore.getState().setUser(data);
+            }
+            // Invalidate related queries
+            if (shouldInvalidateUserQueries) {
+                invalidateUserQueries(queryClient);
+            }
+            if (shouldInvalidateAccountQueries) {
+                invalidateAccountQueries(queryClient);
+            }
+            // Show success toast if configured
+            if (successMessage) {
+                toast.success(successMessage);
+            }
+            // Call custom onSuccess handler
+            if (customOnSuccess) {
+                customOnSuccess(data, variables, queryClient);
+            }
+        },
+    };
+}
+/**
+ * Creates a generic mutation with optimistic updates
+ */
+export function createGenericMutation(config, queryClient) {
+    const { mutationFn, queryKey, optimisticData, errorMessage = 'Operation failed', successMessage, invalidateQueries = [], } = config;
+    return {
+        mutationFn,
+        onMutate: async (variables) => {
+            await queryClient.cancelQueries({ queryKey });
+            const previous = queryClient.getQueryData(queryKey);
+            if (optimisticData) {
+                queryClient.setQueryData(queryKey, optimisticData(previous, variables));
+            }
+            return { previous };
+        },
+        onError: (error, _variables, context) => {
+            if (context?.previous !== undefined) {
+                queryClient.setQueryData(queryKey, context.previous);
+            }
+            toast.error(error instanceof Error ? error.message : errorMessage);
+        },
+        onSuccess: (data) => {
+            queryClient.setQueryData(queryKey, data);
+            for (const key of invalidateQueries) {
+                queryClient.invalidateQueries({ queryKey: key });
+            }
+            if (successMessage) {
+                toast.success(successMessage);
+            }
+        },
+    };
+}