@umituz/react-native-auth 3.2.15 → 3.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-auth",
-  "version": "3.2.15",
+  "version": "3.3.0",
   "description": "Authentication service for React Native apps - Secure, type-safe, and production-ready. Provider-agnostic design with dependency injection, configurable validation, and comprehensive error handling.",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/index.ts

@@ -93,9 +93,19 @@ export {
   configureUserDocumentService,
 } from './infrastructure/services/UserDocumentService';
 
+// Unified Auth Initialization (RECOMMENDED)
+export {
+  initializeAuth,
+  isAuthInitialized,
+  resetAuthInitialization,
+} from './infrastructure/services/initializeAuth';
+
+export type { InitializeAuthOptions } from './infrastructure/services/initializeAuth';
+
 export type {
   UserDocumentConfig,
   UserDocumentExtras,
+  UserDocumentUser,
 } from './infrastructure/services/UserDocumentService';
 
 // =============================================================================

package/src/infrastructure/services/UserDocumentService.ts

@@ -5,11 +5,23 @@
  */
 
 import { doc, getDoc, setDoc, serverTimestamp } from "firebase/firestore";
+import type { User } from "firebase/auth";
 import { getFirestore } from "@umituz/react-native-firebase";
-import type { AuthUser } from "../../domain/entities/AuthUser";
 
 declare const __DEV__: boolean;
 
+/**
+ * Minimal user interface for document creation
+ * Compatible with both Firebase User and AuthUser
+ */
+export interface UserDocumentUser {
+  uid: string;
+  displayName?: string | null;
+  email?: string | null;
+  photoURL?: string | null;
+  isAnonymous?: boolean;
+}
+
 /**
  * Configuration for user document service
  */
@@ -51,7 +63,7 @@ export function configureUserDocumentService(config: UserDocumentConfig): void {
 /**
  * Get sign-up method from auth user
  */
-function getSignUpMethod(user: AuthUser): string | undefined {
+function getSignUpMethod(user: UserDocumentUser): string | undefined {
   if (user.isAnonymous) return "anonymous";
   if (user.email) {
     const providerData = (
@@ -72,7 +84,7 @@ function getSignUpMethod(user: AuthUser): string | undefined {
  * Build base user data from auth user
  */
 function buildBaseData(
-  user: AuthUser,
+  user: UserDocumentUser,
   extras?: UserDocumentExtras,
 ): Record<string, unknown> {
   const data: Record<string, unknown> = {
@@ -153,7 +165,7 @@ function buildUpdateData(
  * Creates new document or updates existing one
  */
 export async function ensureUserDocument(
-  user: AuthUser,
+  user: UserDocumentUser | User,
   extras?: UserDocumentExtras,
 ): Promise<boolean> {
   const db = getFirestore();

package/src/infrastructure/services/initializeAuth.ts

@@ -0,0 +1,134 @@
+/**
+ * Unified Auth Initialization
+ * Single function to initialize all auth services
+ *
+ * Combines:
+ * - AuthService (email/password auth)
+ * - Auth Listener (state management)
+ * - User Document Service (Firestore)
+ */
+
+import type { Auth, User } from "firebase/auth";
+import { getFirebaseAuth } from "@umituz/react-native-firebase";
+import { initializeAuthService } from "./AuthService";
+import { configureUserDocumentService, ensureUserDocument } from "./UserDocumentService";
+import type { UserDocumentConfig } from "./UserDocumentService";
+import { initializeAuthListener } from "../../presentation/stores/initializeAuthListener";
+import type { AuthConfig } from "../../domain/value-objects/AuthConfig";
+
+/**
+ * Unified auth initialization options
+ */
+export interface InitializeAuthOptions {
+  /** User document collection name (default: "users") */
+  userCollection?: string;
+
+  /** Additional fields to store with user documents */
+  extraFields?: Record<string, unknown>;
+
+  /** Callback to collect device/app info for user documents */
+  collectExtras?: () => Promise<Record<string, unknown>>;
+
+  /** Enable auto anonymous sign-in (default: true) */
+  autoAnonymousSignIn?: boolean;
+
+  /** Callback when auth state changes */
+  onAuthStateChange?: (user: User | null) => void | Promise<void>;
+
+  /** Auth configuration (password rules, etc.) */
+  authConfig?: Partial<AuthConfig>;
+}
+
+let isInitialized = false;
+
+/**
+ * Initialize all auth services with a single call
+ *
+ * @example
+ * ```typescript
+ * import { initializeAuth, ensureUserDocument } from '@umituz/react-native-auth';
+ *
+ * await initializeAuth({
+ *   userCollection: 'users',
+ *   autoAnonymousSignIn: true,
+ *   onAuthStateChange: async (user) => {
+ *     if (user) {
+ *       await ensureUserDocument(user);
+ *     }
+ *   },
+ * });
+ * ```
+ */
+export async function initializeAuth(
+  options: InitializeAuthOptions = {}
+): Promise<{ success: boolean; auth: Auth | null }> {
+  if (isInitialized) {
+    const auth = getFirebaseAuth();
+    return { success: true, auth };
+  }
+
+  const {
+    userCollection = "users",
+    extraFields,
+    collectExtras,
+    autoAnonymousSignIn = true,
+    onAuthStateChange,
+    authConfig,
+  } = options;
+
+  // 1. Configure user document service
+  const userDocConfig: UserDocumentConfig = {
+    collectionName: userCollection,
+  };
+  if (extraFields) userDocConfig.extraFields = extraFields;
+  if (collectExtras) userDocConfig.collectExtras = collectExtras;
+
+  configureUserDocumentService(userDocConfig);
+
+  // 2. Get Firebase Auth
+  const auth = getFirebaseAuth();
+  if (!auth) {
+    return { success: false, auth: null };
+  }
+
+  // 3. Initialize AuthService (for email/password auth)
+  try {
+    await initializeAuthService(auth, authConfig);
+  } catch {
+    // AuthService initialization failed, but we can continue
+    // Email/password auth won't work, but social/anonymous will
+  }
+
+  // 4. Initialize Auth Listener (for state management)
+  initializeAuthListener({
+    autoAnonymousSignIn,
+    onAuthStateChange: async (user) => {
+      // Auto-create/update user document
+      if (user) {
+        await ensureUserDocument(user);
+      }
+
+      // Call app's custom callback
+      if (onAuthStateChange) {
+        await onAuthStateChange(user);
+      }
+    },
+  });
+
+  isInitialized = true;
+  return { success: true, auth };
+}
+
+/**
+ * Check if auth is initialized
+ */
+export function isAuthInitialized(): boolean {
+  return isInitialized;
+}
+
+/**
+ * Reset auth initialization state (for testing)
+ */
+export function resetAuthInitialization(): void {
+  isInitialized = false;
+}