@pixygon/auth 1.0.0

package/src/hooks/useProfileSync.ts

@@ -0,0 +1,201 @@
+/**
+ * Profile Sync Hook
+ * Synchronizes user profile data across Pixygon applications
+ */
+
+import { useState, useEffect, useCallback } from 'react';
+import { useAuthContext } from '../providers/AuthProvider';
+import type { User } from '../types';
+
+export interface UserProfile extends User {
+  displayName?: string;
+  avatar?: string;
+  bio?: string;
+  preferences?: Record<string, unknown>;
+  linkedApps?: string[];
+  lastSyncedAt?: string;
+}
+
+export interface UseProfileSyncReturn {
+  /** Current user profile */
+  profile: UserProfile | null;
+  /** Whether the profile is loading */
+  isLoading: boolean;
+  /** Whether the profile is syncing */
+  isSyncing: boolean;
+  /** Error if any */
+  error: Error | null;
+  /** Update profile */
+  updateProfile: (updates: Partial<UserProfile>) => Promise<void>;
+  /** Force sync profile from server */
+  syncProfile: () => Promise<void>;
+  /** Update preferences */
+  updatePreferences: (preferences: Record<string, unknown>) => Promise<void>;
+  /** Link another app to profile */
+  linkApp: (appId: string) => Promise<void>;
+}
+
+/**
+ * Hook to sync user profile across apps
+ */
+export function useProfileSync(): UseProfileSyncReturn {
+  const { user, config, getAccessToken } = useAuthContext();
+  const [profile, setProfile] = useState<UserProfile | null>(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const [isSyncing, setIsSyncing] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  // Fetch profile from server
+  const fetchProfile = useCallback(async () => {
+    const token = getAccessToken();
+    if (!token || !user) {
+      setProfile(null);
+      setIsLoading(false);
+      return;
+    }
+
+    try {
+      const response = await fetch(`${config.baseUrl}/users/profile`, {
+        headers: {
+          'Authorization': `Bearer ${token}`,
+          'Content-Type': 'application/json',
+          'X-App-Id': config.appId,
+        },
+      });
+
+      if (!response.ok) {
+        throw new Error('Failed to fetch profile');
+      }
+
+      const data = await response.json();
+      setProfile({
+        ...user,
+        ...data.user,
+        lastSyncedAt: new Date().toISOString(),
+      });
+      setError(null);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error('Failed to fetch profile'));
+      // Use local user data as fallback
+      setProfile(user ? { ...user, lastSyncedAt: undefined } : null);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [config.baseUrl, config.appId, getAccessToken, user]);
+
+  // Initial load
+  useEffect(() => {
+    if (user) {
+      fetchProfile();
+    } else {
+      setProfile(null);
+      setIsLoading(false);
+    }
+  }, [user, fetchProfile]);
+
+  // Sync profile from server
+  const syncProfile = useCallback(async () => {
+    if (!user) return;
+
+    setIsSyncing(true);
+    await fetchProfile();
+    setIsSyncing(false);
+  }, [user, fetchProfile]);
+
+  // Update profile
+  const updateProfile = useCallback(async (updates: Partial<UserProfile>) => {
+    const token = getAccessToken();
+    if (!token || !profile) {
+      throw new Error('Not authenticated');
+    }
+
+    setIsSyncing(true);
+    try {
+      const response = await fetch(`${config.baseUrl}/users/profile`, {
+        method: 'PATCH',
+        headers: {
+          'Authorization': `Bearer ${token}`,
+          'Content-Type': 'application/json',
+          'X-App-Id': config.appId,
+        },
+        body: JSON.stringify(updates),
+      });
+
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(errorData.message || 'Failed to update profile');
+      }
+
+      const data = await response.json();
+      setProfile({
+        ...profile,
+        ...data.user,
+        lastSyncedAt: new Date().toISOString(),
+      });
+      setError(null);
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error('Failed to update profile');
+      setError(error);
+      throw error;
+    } finally {
+      setIsSyncing(false);
+    }
+  }, [config.baseUrl, config.appId, getAccessToken, profile]);
+
+  // Update preferences
+  const updatePreferences = useCallback(async (preferences: Record<string, unknown>) => {
+    await updateProfile({
+      preferences: {
+        ...profile?.preferences,
+        ...preferences,
+      },
+    });
+  }, [updateProfile, profile?.preferences]);
+
+  // Link another app
+  const linkApp = useCallback(async (appId: string) => {
+    const token = getAccessToken();
+    if (!token) {
+      throw new Error('Not authenticated');
+    }
+
+    setIsSyncing(true);
+    try {
+      const response = await fetch(`${config.baseUrl}/users/link-app`, {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${token}`,
+          'Content-Type': 'application/json',
+          'X-App-Id': config.appId,
+        },
+        body: JSON.stringify({ appId }),
+      });
+
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(errorData.message || 'Failed to link app');
+      }
+
+      // Refresh profile to get updated linked apps
+      await fetchProfile();
+      setError(null);
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error('Failed to link app');
+      setError(error);
+      throw error;
+    } finally {
+      setIsSyncing(false);
+    }
+  }, [config.baseUrl, config.appId, getAccessToken, fetchProfile]);
+
+  return {
+    profile,
+    isLoading,
+    isSyncing,
+    error,
+    updateProfile,
+    syncProfile,
+    updatePreferences,
+    linkApp,
+  };
+}

package/src/index.ts

@@ -0,0 +1,99 @@
+/**
+ * @pixygon/auth
+ * Shared authentication package for all Pixygon applications
+ *
+ * Usage:
+ * ```tsx
+ * import { AuthProvider, useAuth } from '@pixygon/auth';
+ *
+ * // Wrap your app
+ * <AuthProvider config={{ baseUrl: '...', appId: 'my-app' }}>
+ *   <App />
+ * </AuthProvider>
+ *
+ * // Use in components
+ * const { user, login, logout, isAuthenticated } = useAuth();
+ * ```
+ */
+
+// Types
+export type {
+  // User types
+  User,
+  UserRole,
+  SubscriptionTier,
+
+  // Token types
+  TokenPair,
+  TokenPayload,
+
+  // State types
+  AuthState,
+  AuthStatus,
+
+  // Request/Response types
+  LoginRequest,
+  LoginResponse,
+  RegisterRequest,
+  RegisterResponse,
+  VerifyRequest,
+  VerifyResponse,
+  ForgotPasswordRequest,
+  ForgotPasswordResponse,
+  RecoverPasswordRequest,
+  RecoverPasswordResponse,
+  RefreshTokenRequest,
+  RefreshTokenResponse,
+  ResendVerificationRequest,
+  ResendVerificationResponse,
+
+  // Error types
+  AuthError,
+  AuthErrorCode,
+
+  // Config types
+  AuthConfig,
+  AuthStorage,
+  AuthContextValue,
+
+  // Component props
+  LoginFormProps,
+  RegisterFormProps,
+  VerifyFormProps,
+  ForgotPasswordFormProps,
+  PixygonAuthProps,
+} from './types';
+
+// Provider
+export { AuthProvider, AuthContext, useAuthContext } from './providers/AuthProvider';
+export type { AuthProviderProps } from './providers/AuthProvider';
+
+// Hooks
+export {
+  useAuth,
+  useUser,
+  useToken,
+  useAuthStatus,
+  useRequireAuth,
+  useAuthError,
+  useProfileSync,
+} from './hooks';
+export type {
+  UseAuthReturn,
+  UseUserReturn,
+  UseTokenReturn,
+  UseAuthStatusReturn,
+  UseRequireAuthOptions,
+  UseRequireAuthReturn,
+  UseAuthErrorReturn,
+  UseProfileSyncReturn,
+  UserProfile,
+} from './hooks';
+
+// Utilities
+export { createTokenStorage } from './utils/storage';
+export type { TokenStorage } from './utils/storage';
+
+// API Client
+export { createAuthApiClient } from './api/client';
+export type { AuthApiClient } from './api/client';