@umituz/react-native-auth 3.6.61 → 3.6.63

package/src/infrastructure/utils/userDocumentBuilder.util.ts

@@ -1,114 +0,0 @@
-/**
- * User Document Builder Utility
- * Builds user document data for Firestore
- */
-
-import { serverTimestamp } from "firebase/firestore";
-import type {
-  UserDocumentUser,
-  UserDocumentExtras,
-} from "../../infrastructure/services/UserDocument.types";
-import { extractProvider } from "./UserMapper";
-import type { AuthProviderType } from "../../domain/entities/AuthUser";
-
-/**
- * Map AuthProviderType to sign-up method string
- */
-const PROVIDER_TO_SIGNUP_METHOD: Record<string, string> = {
-  "google.com": "google",
-  "apple.com": "apple",
-  "password": "email",
-  "anonymous": "anonymous",
-};
-
-/**
- * Gets the sign-up method from user provider data
- * Uses extractProvider from UserMapper as single source of truth for provider detection
- */
-export function getSignUpMethod(user: UserDocumentUser): string | undefined {
-  const provider: AuthProviderType = extractProvider(user as Parameters<typeof extractProvider>[0]);
-  if (provider === "unknown") return user.email ? "email" : undefined;
-  return PROVIDER_TO_SIGNUP_METHOD[provider];
-}
-
-/**
- * Builds base user data from user object and extras
- */
-export function buildBaseData(
-  user: UserDocumentUser,
-  extras?: UserDocumentExtras,
-): Record<string, unknown> {
-  const data: Record<string, unknown> = {
-    displayName: user.displayName,
-    email: user.email,
-    photoURL: user.photoURL,
-    isAnonymous: user.isAnonymous,
-  };
-
-  if (extras) {
-    const internalFields = ["signUpMethod", "previousAnonymousUserId"];
-    Object.keys(extras).forEach((key) => {
-      if (!internalFields.includes(key)) {
-        const val = extras[key];
-        if (val !== undefined) {
-          data[key] = val;
-        }
-      }
-    });
-  }
-
-  return data;
-}
-
-/**
- * Apply anonymous-to-authenticated conversion fields to document data
- */
-function applyConversionFields(data: Record<string, unknown>, extras?: UserDocumentExtras): void {
-  if (extras?.previousAnonymousUserId) {
-    data.previousAnonymousUserId = extras.previousAnonymousUserId;
-    data.convertedFromAnonymous = true;
-    data.convertedAt = serverTimestamp();
-  }
-  if (extras?.signUpMethod) {
-    data.signUpMethod = extras.signUpMethod;
-  }
-}
-
-/**
- * Builds user document data for creation
- */
-export function buildCreateData(
-  baseData: Record<string, unknown>,
-  extraFields: Record<string, unknown> | undefined,
-  extras?: UserDocumentExtras,
-): Record<string, unknown> {
-  const createData: Record<string, unknown> = {
-    ...baseData,
-    ...extraFields,
-    createdAt: serverTimestamp(),
-    updatedAt: serverTimestamp(),
-    lastLoginAt: serverTimestamp(),
-  };
-
-  applyConversionFields(createData, extras);
-
-  return createData;
-}
-
-/**
- * Builds user document data for update
- */
-export function buildUpdateData(
-  baseData: Record<string, unknown>,
-  extras?: UserDocumentExtras,
-): Record<string, unknown> {
-  const updateData: Record<string, unknown> = {
-    ...baseData,
-    lastLoginAt: serverTimestamp(),
-    updatedAt: serverTimestamp(),
-  };
-
-  applyConversionFields(updateData, extras);
-
-  return updateData;
-}

package/src/infrastructure/utils/validation/BaseValidators.ts

@@ -1,35 +0,0 @@
-import { ValidationResult } from './types';
-
-/**
- * Validate required field (not null, undefined, or empty string)
- */
-export const validateRequired = (
-  value: unknown,
-  fieldName: string = "Field",
-  errorKey?: string
-): ValidationResult => {
-  const isValid = value !== undefined && value !== null && (typeof value === 'string' ? value.trim() !== "" : true);
-  
-  return {
-    isValid,
-    error: isValid ? undefined : (errorKey || `${fieldName} is required`)
-  };
-};
-
-/**
- * Validate pattern (regex)
- */
-export const validatePattern = (
-  value: string,
-  pattern: RegExp,
-  fieldName: string = "Field",
-  errorKey?: string
-): ValidationResult => {
-  if (!value) return { isValid: true }; // Use validateRequired for mandatory check
-
-  const isValid = pattern.test(value);
-  return {
-    isValid,
-    error: isValid ? undefined : (errorKey || `${fieldName} format is invalid`)
-  };
-};

package/src/infrastructure/utils/validation/CollectionValidators.ts

@@ -1,56 +0,0 @@
-import { ValidationResult } from './types';
-
-/**
- * Custom enum validation
- * Generic validator for enum-like values with custom options
- */
-export const validateEnum = (
-  value: string,
-  validOptions: readonly string[],
-  fieldName: string = "Field",
-  errorKey?: string
-): ValidationResult => {
-  if (!value || value.trim() === "") {
-    return { isValid: false, error: `${fieldName} is required` };
-  }
-
-  const isValid = validOptions.includes(value.toLowerCase());
-  return {
-    isValid,
-    error: isValid ? undefined : (errorKey || `Please select a valid ${fieldName.toLowerCase()}`)
-  };
-};
-
-/**
- * Tags validation
- * Generic validator for array of strings with constraints
- */
-export const validateTags = (
-  tags: string[],
-  maxTags: number = 10,
-  maxTagLength: number = 20,
-  errorKey?: string
-): ValidationResult => {
-  if (!Array.isArray(tags)) {
-    return { isValid: false, error: errorKey || "Tags must be an array" };
-  }
-
-  if (tags.length > maxTags) {
-    return { isValid: false, error: errorKey || `Maximum ${maxTags} tags allowed` };
-  }
-
-  for (const tag of tags) {
-    if (typeof tag !== "string" || tag.trim().length === 0) {
-      return { isValid: false, error: errorKey || "All tags must be non-empty strings" };
-    }
-
-    if (tag.trim().length > maxTagLength) {
-      return {
-        isValid: false,
-        error: errorKey || `Each tag must be at most ${maxTagLength} characters`,
-      };
-    }
-  }
-
-  return { isValid: true };
-};

package/src/infrastructure/utils/validation/DateValidators.ts

@@ -1,71 +0,0 @@
-import { ValidationResult } from './types';
-
-/**
- * Calculate age from a birth date
- */
-export function calculateAge(birthDate: Date): number {
-  const today = new Date();
-  let age = today.getFullYear() - birthDate.getFullYear();
-  const m = today.getMonth() - birthDate.getMonth();
-  if (m < 0 || (m === 0 && today.getDate() < birthDate.getDate())) {
-    age--;
-  }
-  return age;
-}
-
-/**
- * Validate date of birth
- */
-export const validateDateOfBirth = (
-  date: Date,
-  minAge: number = 13,
-  errorKey?: string
-): ValidationResult => {
-  if (!date || !(date instanceof Date) || isNaN(date.getTime())) {
-    return { isValid: false, error: "Please enter a valid date" };
-  }
-
-  const age = calculateAge(date);
-
-  if (age < minAge) {
-    return { isValid: false, error: errorKey || `You must be at least ${minAge} years old` };
-  }
-
-  if (age > 120) {
-    return { isValid: false, error: "Please enter a valid date of birth" };
-  }
-
-  return { isValid: true };
-};
-
-/**
- * Date range validation
- * Validates date is within a specific range
- */
-export const validateDateRange = (
-  date: Date,
-  minDate?: Date,
-  maxDate?: Date,
-  fieldName: string = "Date",
-  errorKey?: string
-): ValidationResult => {
-  if (!date || !(date instanceof Date) || isNaN(date.getTime())) {
-    return { isValid: false, error: errorKey || `Please enter a valid ${fieldName.toLowerCase()}` };
-  }
-
-  if (minDate && date < minDate) {
-    return {
-      isValid: false,
-      error: errorKey || `${fieldName} cannot be before ${minDate.toLocaleDateString()}`,
-    };
-  }
-
-  if (maxDate && date > maxDate) {
-    return {
-      isValid: false,
-      error: errorKey || `${fieldName} cannot be after ${maxDate.toLocaleDateString()}`,
-    };
-  }
-
-  return { isValid: true };
-};

package/src/infrastructure/utils/validation/FormValidators.ts

@@ -1,22 +0,0 @@
-import { ValidationResult } from './types';
-
-/**
- * Batch validation helper
- * Validates multiple fields and returns all errors in a record
- */
-export const batchValidate = (
-  validations: Array<{ field: string; validator: () => ValidationResult }>,
-): { isValid: boolean; errors: Record<string, string> } => {
-  const errors: Record<string, string> = {};
-  let isValid = true;
-
-  validations.forEach(({ field, validator }) => {
-    const result = validator();
-    if (!result.isValid && result.error) {
-      errors[field] = result.error;
-      isValid = false;
-    }
-  });
-
-  return { isValid, errors };
-};

package/src/infrastructure/utils/validation/NumberValidators.ts

@@ -1,50 +0,0 @@
-import { ValidationResult } from './types';
-import { calculateAge } from './DateValidators';
-
-/**
- * Validate numeric range
- */
-export const validateNumberRange = (
-  value: number,
-  min: number,
-  max: number,
-  fieldName: string = "Number",
-  errorKey?: string
-): ValidationResult => {
-  const isValid = value >= min && value <= max;
-  return {
-    isValid,
-    error: isValid ? undefined : (errorKey || `${fieldName} must be between ${min} and ${max}`)
-  };
-};
-
-/**
- * Validate positive number
- */
-export const validatePositiveNumber = (
-  value: number,
-  fieldName: string = "Number",
-  errorKey?: string
-): ValidationResult => {
-  const isValid = value > 0;
-  return {
-    isValid,
-    error: isValid ? undefined : (errorKey || `${fieldName} must be a positive number`)
-  };
-};
-
-/**
- * Validate age based on birth date
- */
-export const validateAge = (
-  birthDate: Date,
-  minAge: number,
-  errorKey?: string
-): ValidationResult => {
-  const age = calculateAge(birthDate);
-  const isValid = age >= minAge;
-  return {
-    isValid,
-    error: isValid ? undefined : (errorKey || `You must be at least ${minAge} years old`)
-  };
-};

package/src/infrastructure/utils/validation/StringValidators.ts

@@ -1,55 +0,0 @@
-import { ValidationResult } from './types';
-
-/**
- * Validate min length of a string
- */
-export const validateMinLength = (
-  value: string,
-  minLength: number,
-  fieldName: string = "Field",
-  errorKey?: string
-): ValidationResult => {
-  if (!value) return { isValid: false, error: `${fieldName} is required` };
-  
-  const isValid = value.trim().length >= minLength;
-  return {
-    isValid,
-    error: isValid ? undefined : (errorKey || `${fieldName} must be at least ${minLength} characters`)
-  };
-};
-
-/**
- * Validate max length of a string
- */
-export const validateMaxLength = (
-  value: string,
-  maxLength: number,
-  fieldName: string = "Field",
-  errorKey?: string
-): ValidationResult => {
-  if (!value) return { isValid: true };
-  
-  const isValid = value.trim().length <= maxLength;
-  return {
-    isValid,
-    error: isValid ? undefined : (errorKey || `${fieldName} must be at most ${maxLength} characters`)
-  };
-};
-
-/**
- * Validate phone number (E.164 format)
- */
-export const validatePhone = (
-  phone: string,
-  errorKey?: string
-): ValidationResult => {
-  if (!phone) return { isValid: true };
-  
-  const phoneRegex = /^\+[1-9]\d{1,14}$/;
-  const isValid = phoneRegex.test(phone);
-  
-  return {
-    isValid,
-    error: isValid ? undefined : (errorKey || "Please enter a valid phone number")
-  };
-};

package/src/infrastructure/utils/validation/types.ts

@@ -1,15 +0,0 @@
-/**
- * Validation Result Interface
- * Represents the outcome of a validation operation
- */
-export interface ValidationResult {
-  /**
-   * Whether the validation passed
-   */
-  isValid: boolean;
-
-  /**
-   * Error message or translation key if validation failed
-   */
-  error?: string;
-}

package/src/presentation/screens/change-password/ChangePasswordScreen.tsx

@@ -1,179 +0,0 @@
-/**
- * Change Password Screen
- */
-
-import React, { useState } from "react";
-import { View, StyleSheet, Alert } from "react-native";
-import {
-  ScreenLayout,
-  ScreenHeader,
-  AtomicInput,
-  AtomicButton,
-  AtomicText,
-  useAppDesignTokens,
-} from "@umituz/react-native-design-system";
-import {
-  updateUserPassword,
-  reauthenticateWithPassword,
-  getCurrentUserFromGlobal,
-} from "@umituz/react-native-firebase";
-import { RequirementItem } from "./RequirementItem";
-import { validatePassword } from "./ChangePasswordScreen.types";
-import type { ChangePasswordScreenProps } from "./ChangePasswordScreen.types";
-
-export type { ChangePasswordTranslations, ChangePasswordScreenProps } from "./ChangePasswordScreen.types";
-
-export const ChangePasswordScreen: React.FC<ChangePasswordScreenProps> = ({
-  translations,
-  onSuccess,
-  onCancel,
-}) => {
-  const tokens = useAppDesignTokens();
-
-  const [currentPassword, setCurrentPassword] = useState("");
-  const [newPassword, setNewPassword] = useState("");
-  const [confirmPassword, setConfirmPassword] = useState("");
-  const [loading, setLoading] = useState(false);
-  const [error, setError] = useState<string | null>(null);
-
-  const validation = validatePassword(newPassword, confirmPassword, currentPassword);
-
-  const handleChangePassword = async () => {
-    if (!validation.isValid) {
-      Alert.alert("Error", translations.fillAllFields);
-      return;
-    }
-
-    const user = getCurrentUserFromGlobal();
-    if (!user) {
-      setError(translations.unauthorized);
-      return;
-    }
-
-    setLoading(true);
-    setError(null);
-
-    try {
-      const reauthResult = await reauthenticateWithPassword(user, currentPassword);
-      if (!reauthResult.success) {
-        setError(reauthResult.error?.message || translations.signInFailed);
-        setLoading(false);
-        return;
-      }
-
-      const updateResult = await updateUserPassword(user, newPassword);
-      if (updateResult.success) {
-        Alert.alert("Success", translations.success, [
-          { text: "OK", onPress: onSuccess }
-        ]);
-      } else {
-        setError(updateResult.error?.message || translations.error);
-      }
-    } catch (e: unknown) {
-      const errorMessage = e instanceof Error ? e.message : translations.error;
-      setError(errorMessage);
-    } finally {
-      setLoading(false);
-    }
-  };
-
-  return (
-    <ScreenLayout
-      scrollable
-      header={<ScreenHeader title={translations.title} />}
-      backgroundColor={tokens.colors.backgroundPrimary}
-      edges={["bottom"]}
-    >
-      <View style={styles.content}>
-        <AtomicText type="bodyMedium" style={{ color: tokens.colors.textSecondary, marginBottom: 24 }}>
-          {translations.description}
-        </AtomicText>
-
-        <View style={styles.form}>
-          <AtomicInput
-            label={translations.currentPassword}
-            placeholder={translations.enterCurrentPassword}
-            value={currentPassword}
-            onChangeText={setCurrentPassword}
-            secureTextEntry
-            showPasswordToggle
-            variant="filled"
-          />
-
-          <AtomicInput
-            label={translations.newPassword}
-            placeholder={translations.enterNewPassword}
-            value={newPassword}
-            onChangeText={setNewPassword}
-            secureTextEntry
-            showPasswordToggle
-            variant="filled"
-          />
-
-          <AtomicInput
-            label={translations.confirmPassword}
-            placeholder={translations.enterConfirmPassword}
-            value={confirmPassword}
-            onChangeText={setConfirmPassword}
-            secureTextEntry
-            showPasswordToggle
-            variant="filled"
-          />
-
-          <View style={[styles.requirementsContainer, { backgroundColor: tokens.colors.surfaceSecondary }]}>
-            <AtomicText type="labelMedium" style={{ color: tokens.colors.textSecondary, marginBottom: 8 }}>
-              {translations.requirements}
-            </AtomicText>
-            <RequirementItem label={translations.minLength} met={validation.isLengthValid} />
-            <RequirementItem label={translations.uppercase} met={validation.hasUppercase} />
-            <RequirementItem label={translations.lowercase} met={validation.hasLowercase} />
-            <RequirementItem label={translations.number} met={validation.hasNumber} />
-            <RequirementItem label={translations.specialChar} met={validation.hasSpecialChar} />
-            <RequirementItem label={translations.passwordsMatch} met={validation.passwordsMatch} />
-          </View>
-
-          {error && (
-            <AtomicText style={{ color: tokens.colors.error, marginTop: 16 }}>
-              {error}
-            </AtomicText>
-          )}
-
-          <View style={styles.actions}>
-            <AtomicButton
-              title={translations.cancel}
-              onPress={onCancel || (() => {})}
-              variant="outline"
-              style={{ flex: 1 }}
-            />
-            <AtomicButton
-              title={loading ? translations.changing : translations.changePassword}
-              onPress={() => { void handleChangePassword(); }}
-              loading={loading}
-              disabled={!validation.isValid || loading}
-              style={{ flex: 1 }}
-            />
-          </View>
-        </View>
-      </View>
-    </ScreenLayout>
-  );
-};
-
-const styles = StyleSheet.create({
-  content: {
-    padding: 16,
-  },
-  form: {
-    gap: 16,
-  },
-  requirementsContainer: {
-    marginTop: 8,
-    padding: 12,
-    borderRadius: 8,
-  },
-  actions: {
-    flexDirection: "row",
-    gap: 12,
-    marginTop: 24,
-  },
-});

package/src/presentation/screens/change-password/ChangePasswordScreen.types.ts

@@ -1,77 +0,0 @@
-/**
- * Change Password Screen Types
- */
-
-export interface ChangePasswordTranslations {
-  title: string;
-  description: string;
-  currentPassword: string;
-  enterCurrentPassword: string;
-  newPassword: string;
-  enterNewPassword: string;
-  confirmPassword: string;
-  enterConfirmPassword: string;
-  requirements: string;
-  minLength: string;
-  uppercase: string;
-  lowercase: string;
-  number: string;
-  specialChar: string;
-  passwordsMatch: string;
-  changePassword: string;
-  changing: string;
-  cancel: string;
-  success: string;
-  error: string;
-  fillAllFields: string;
-  unauthorized: string;
-  signInFailed: string;
-}
-
-export interface ChangePasswordScreenProps {
-  translations: ChangePasswordTranslations;
-  onSuccess?: () => void;
-  onCancel?: () => void;
-}
-
-export interface PasswordValidation {
-  isLengthValid: boolean;
-  hasUppercase: boolean;
-  hasLowercase: boolean;
-  hasNumber: boolean;
-  hasSpecialChar: boolean;
-  passwordsMatch: boolean;
-  isValid: boolean;
-}
-
-export function validatePassword(
-  newPassword: string,
-  confirmPassword: string,
-  currentPassword: string
-): PasswordValidation {
-  const isLengthValid = newPassword.length >= 8;
-  const hasUppercase = /[A-Z]/.test(newPassword);
-  const hasLowercase = /[a-z]/.test(newPassword);
-  const hasNumber = /[0-9]/.test(newPassword);
-  const hasSpecialChar = /[!@#$%^&*]/.test(newPassword);
-  const passwordsMatch = newPassword === confirmPassword && newPassword !== "";
-
-  const isValid =
-    isLengthValid &&
-    hasUppercase &&
-    hasLowercase &&
-    hasNumber &&
-    hasSpecialChar &&
-    passwordsMatch &&
-    currentPassword.length > 0;
-
-  return {
-    isLengthValid,
-    hasUppercase,
-    hasLowercase,
-    hasNumber,
-    hasSpecialChar,
-    passwordsMatch,
-    isValid,
-  };
-}