@umituz/react-native-auth 3.6.72 → 3.6.74

package/src/presentation/utils/form/formValidation.util.ts

@@ -0,0 +1,173 @@
+/**
+ * Form Validation Utilities
+ * Shared validation logic for all auth forms
+ */
+
+import { useCallback } from "react";
+import {
+  validateEmail,
+  validatePasswordForLogin,
+  validatePasswordForRegister,
+  validatePasswordConfirmation,
+} from "../../../infrastructure/utils/AuthValidation";
+import type { PasswordConfig } from "../../../domain/value-objects/AuthConfig";
+
+export interface FormValidationError {
+  field: string;
+  message: string;
+}
+
+export interface FormValidationResult {
+  isValid: boolean;
+  errors: FormValidationError[];
+}
+
+export interface LoginFormValues {
+  email: string;
+  password: string;
+}
+
+export interface RegisterFormValues {
+  displayName?: string;
+  email: string;
+  password: string;
+  confirmPassword: string;
+}
+
+export interface ProfileFormValues {
+  displayName: string;
+  email: string;
+}
+
+/**
+ * Validate login form fields
+ * @param values - Form values to validate
+ * @param getErrorMessage - Function to get localized error messages
+ * @returns Validation result
+ */
+export function validateLoginForm(
+  values: LoginFormValues,
+  getErrorMessage: (key: string) => string
+): FormValidationResult {
+  const errors: FormValidationError[] = [];
+
+  const emailResult = validateEmail(values.email.trim());
+  if (!emailResult.isValid && emailResult.error) {
+    errors.push({ field: "email", message: getErrorMessage(emailResult.error) });
+  }
+
+  const passwordResult = validatePasswordForLogin(values.password);
+  if (!passwordResult.isValid && passwordResult.error) {
+    errors.push({ field: "password", message: getErrorMessage(passwordResult.error) });
+  }
+
+  return {
+    isValid: errors.length === 0,
+    errors,
+  };
+}
+
+/**
+ * Validate register form fields
+ * @param values - Form values to validate
+ * @param getErrorMessage - Function to get localized error messages
+ * @param passwordConfig - Password configuration
+ * @returns Validation result
+ */
+export function validateRegisterForm(
+  values: RegisterFormValues,
+  getErrorMessage: (key: string) => string,
+  passwordConfig: PasswordConfig
+): FormValidationResult {
+  const errors: FormValidationError[] = [];
+
+  const emailResult = validateEmail(values.email.trim());
+  if (!emailResult.isValid && emailResult.error) {
+    errors.push({ field: "email", message: getErrorMessage(emailResult.error) });
+  }
+
+  const passwordResult = validatePasswordForRegister(values.password, passwordConfig);
+  if (!passwordResult.isValid && passwordResult.error) {
+    errors.push({ field: "password", message: getErrorMessage(passwordResult.error) });
+  }
+
+  const confirmResult = validatePasswordConfirmation(values.password, values.confirmPassword);
+  if (!confirmResult.isValid && confirmResult.error) {
+    errors.push({ field: "confirmPassword", message: getErrorMessage(confirmResult.error) });
+  }
+
+  return {
+    isValid: errors.length === 0,
+    errors,
+  };
+}
+
+/**
+ * Validate profile form fields
+ * @param values - Form values to validate
+ * @returns Validation result
+ */
+export function validateProfileForm(values: ProfileFormValues): FormValidationResult {
+  const errors: FormValidationError[] = [];
+
+  if (!values.displayName.trim()) {
+    errors.push({ field: "displayName", message: "Display name is required" });
+  }
+
+  if (values.email) {
+    const emailResult = validateEmail(values.email);
+    if (!emailResult.isValid && emailResult.error) {
+      errors.push({ field: "email", message: emailResult.error });
+    }
+  }
+
+  return {
+    isValid: errors.length === 0,
+    errors,
+  };
+}
+
+/**
+ * Convert validation errors to field error object
+ * @param errors - Validation errors
+ * @returns Object mapping field names to error messages
+ */
+export function errorsToFieldErrors(
+  errors: FormValidationError[]
+): Record<string, string> {
+  const result: Record<string, string> = {};
+  for (const error of errors) {
+    result[error.field] = error.message;
+  }
+  return result;
+}
+
+/**
+ * Hook for form validation with error message resolution
+ * @param getErrorMessage - Function to get localized error messages
+ * @returns Validation functions
+ */
+export function useFormValidation(getErrorMessage: (key: string) => string) {
+  const validateLogin = useCallback(
+    (values: LoginFormValues) => validateLoginForm(values, getErrorMessage),
+    [getErrorMessage]
+  );
+
+  const validateRegister = useCallback(
+    (values: RegisterFormValues, passwordConfig: PasswordConfig) =>
+      validateRegisterForm(values, getErrorMessage, passwordConfig),
+    [getErrorMessage]
+  );
+
+  const validateProfile = useCallback(
+    (values: ProfileFormValues) => validateProfileForm(values),
+    []
+  );
+
+  return {
+    validateLogin,
+    validateRegister,
+    validateProfile,
+    errorsToFieldErrors,
+  };
+}

package/src/presentation/utils/socialAuthHandler.util.ts

@@ -0,0 +1,106 @@
+/**
+ * Social Auth Handler Utilities
+ * Manages social authentication state and handlers
+ */
+
+import { useState, useCallback } from "react";
+import type { SocialAuthProvider } from "../../domain/value-objects/AuthConfig";
+import { Platform } from "react-native";
+
+export interface SocialAuthHandlers {
+  googleLoading: boolean;
+  appleLoading: boolean;
+  handleGoogleSignIn: () => Promise<void>;
+  handleAppleSignIn: () => Promise<void>;
+}
+
+export interface SocialAuthConfig {
+  google?: { iosClientId?: string; webClientId?: string; androidClientId?: string };
+  apple?: { enabled: boolean };
+}
+
+/**
+ * Hook for managing social auth loading states
+ */
+export function useSocialAuthLoading() {
+  const [googleLoading, setGoogleLoading] = useState(false);
+  const [appleLoading, setAppleLoading] = useState(false);
+
+  const createGoogleHandler = useCallback(
+    (handler: () => Promise<void>) => {
+      return async () => {
+        setGoogleLoading(true);
+        try {
+          await handler();
+        } finally {
+          setGoogleLoading(false);
+        }
+      };
+    },
+    []
+  );
+
+  const createAppleHandler = useCallback(
+    (handler: () => Promise<void>) => {
+      return async () => {
+        setAppleLoading(true);
+        try {
+          await handler();
+        } finally {
+          setAppleLoading(false);
+        }
+      };
+    },
+    []
+  );
+
+  return {
+    googleLoading,
+    appleLoading,
+    setGoogleLoading,
+    setAppleLoading,
+    createGoogleHandler,
+    createAppleHandler,
+  };
+}
+
+/**
+ * Determine enabled social auth providers
+ */
+export function determineEnabledProviders(
+  config: SocialAuthConfig | undefined,
+  appleAvailable: boolean,
+  googleConfigured: boolean
+): SocialAuthProvider[] {
+  const providers: SocialAuthProvider[] = [];
+
+  if (Platform.OS === "ios" && config?.apple?.enabled && appleAvailable) {
+    providers.push("apple");
+  }
+
+  if (googleConfigured) {
+    providers.push("google");
+  }
+
+  return providers;
+}
+
+/**
+ * Create social auth handlers
+ */
+export function createSocialAuthHandlers(
+  googleSignIn: (() => Promise<void>) | undefined,
+  appleSignIn: (() => Promise<void>) | undefined,
+  internalGoogleHandler: (() => Promise<void>) | undefined,
+  internalAppleHandler: (() => Promise<void>) | undefined
+): SocialAuthHandlers {
+  const googleHandler = googleSignIn || internalGoogleHandler;
+  const appleHandler = appleSignIn || internalAppleHandler;
+
+  return {
+    googleLoading: false,
+    appleLoading: false,
+    handleGoogleSignIn: googleHandler || (async () => {}),
+    handleAppleSignIn: appleHandler || (async () => {}),
+  };
+}