@umituz/react-native-firebase 1.13.149 → 1.13.150

package/src/domain/utils/executors/batch-executors.util.ts

@@ -0,0 +1,42 @@
+/**
+ * Batch Async Executors
+ * Execute multiple operations in parallel or sequence
+ */
+
+import type { Result, FailureResult } from '../result.util';
+import { failureResultFromError, successResult } from '../result.util';
+
+/**
+ * Execute multiple operations in parallel
+ * Returns success only if all operations succeed
+ */
+export async function executeAll<T>(
+  ...operations: (() => Promise<Result<T>>)[]
+): Promise<Result<T[]>> {
+  try {
+    const results = await Promise.all(operations.map((op) => op()));
+    const failures = results.filter((r) => !r.success);
+    if (failures.length > 0) {
+      return failures[0] as FailureResult;
+    }
+    const data = results.map((r) => (r as { success: true; data: T }).data);
+    return successResult(data);
+  } catch (error) {
+    return failureResultFromError(error);
+  }
+}
+
+/**
+ * Execute operations in sequence, stopping at first failure
+ */
+export async function executeSequence<T>(
+  ...operations: (() => Promise<Result<T>>)[]
+): Promise<Result<void>> {
+  for (const operation of operations) {
+    const result = await operation();
+    if (!result.success) {
+      return result as Result<void>;
+    }
+  }
+  return successResult();
+}

package/src/domain/utils/executors/error-converters.util.ts

@@ -0,0 +1,45 @@
+/**
+ * Error Converters
+ * Convert unknown errors to structured ErrorInfo
+ */
+
+/**
+ * Error converter function type
+ * Converts unknown errors to ErrorInfo
+ */
+export type ErrorConverter = (error: unknown) => { code: string; message: string };
+
+/**
+ * Default error converter for auth operations
+ */
+export function authErrorConverter(error: unknown): { code: string; message: string } {
+  if (error instanceof Error) {
+    return {
+      code: (error as { code?: string }).code ?? 'auth/failed',
+      message: error.message,
+    };
+  }
+  return {
+    code: 'auth/failed',
+    message: typeof error === 'string' ? error : 'Authentication failed',
+  };
+}
+
+/**
+ * Default error converter for operations
+ */
+export function defaultErrorConverter(
+  error: unknown,
+  defaultCode = 'operation/failed'
+): { code: string; message: string } {
+  if (error instanceof Error) {
+    return {
+      code: (error as { code?: string }).code ?? defaultCode,
+      message: error.message,
+    };
+  }
+  return {
+    code: defaultCode,
+    message: typeof error === 'string' ? error : 'Operation failed',
+  };
+}

package/src/domain/utils/result/result-creators.ts

@@ -0,0 +1,49 @@
+/**
+ * Result Creators
+ * Factory functions for creating Result instances
+ */
+
+import type { SuccessResult, FailureResult, ErrorInfo } from './result-types';
+
+/**
+ * Create a success result with optional data
+ */
+export function successResult<T = void>(data?: T): SuccessResult<T> {
+  return { success: true, data: data as T };
+}
+
+/**
+ * Create a failure result with error information
+ */
+export function failureResult(error: ErrorInfo): FailureResult {
+  return { success: false, error };
+}
+
+/**
+ * Create a failure result from error code and message
+ */
+export function failureResultFrom(code: string, message: string): FailureResult {
+  return { success: false, error: { code, message } };
+}
+
+/**
+ * Create a failure result from an unknown error
+ */
+export function failureResultFromError(error: unknown, defaultCode = 'operation/failed'): FailureResult {
+  if (error instanceof Error) {
+    return {
+      success: false,
+      error: {
+        code: (error as { code?: string }).code ?? defaultCode,
+        message: error.message,
+      },
+    };
+  }
+  return {
+    success: false,
+    error: {
+      code: defaultCode,
+      message: typeof error === 'string' ? error : 'Unknown error occurred',
+    },
+  };
+}

package/src/domain/utils/result/result-helpers.ts

@@ -0,0 +1,60 @@
+/**
+ * Result Helpers
+ * Utility functions for working with Result type
+ */
+
+import type { Result, SuccessResult, FailureResult } from './result-types';
+import { successResult } from './result-creators';
+
+/**
+ * Check if result is successful
+ */
+export function isSuccess<T>(result: Result<T>): result is SuccessResult<T> {
+  return result.success === true && result.error === undefined;
+}
+
+/**
+ * Check if result is a failure
+ */
+export function isFailure<T>(result: Result<T>): result is FailureResult {
+  return result.success === false;
+}
+
+/**
+ * Get data from result or return default
+ */
+export function getDataOrDefault<T>(result: Result<T>, defaultValue: T): T {
+  return isSuccess(result) ? (result.data ?? defaultValue) : defaultValue;
+}
+
+/**
+ * Map success result data to another type
+ */
+export function mapResult<T, U>(
+  result: Result<T>,
+  mapper: (data: T) => U
+): Result<U> {
+  if (isSuccess(result) && result.data !== undefined) {
+    return successResult(mapper(result.data));
+  }
+  // Return a new failure result to avoid type conflicts
+  if (isFailure(result)) {
+    return { success: false, error: result.error };
+  }
+  return successResult();
+}
+
+/**
+ * Chain multiple results, stopping at first failure
+ */
+export async function chainResults<T>(
+  ...operations: (() => Promise<Result<T>>)[]
+): Promise<Result<T>> {
+  for (const operation of operations) {
+    const result = await operation();
+    if (isFailure(result)) {
+      return result;
+    }
+  }
+  return successResult();
+}

package/src/domain/utils/result/result-types.ts

@@ -0,0 +1,40 @@
+/**
+ * Result Types
+ * Type definitions for Result pattern
+ */
+
+/**
+ * Standard error information structure
+ */
+export interface ErrorInfo {
+  code: string;
+  message: string;
+}
+
+/**
+ * Standard result type for operations
+ * Success contains data, failure contains error info
+ */
+export interface Result<T = void> {
+  readonly success: boolean;
+  readonly data?: T;
+  readonly error?: ErrorInfo;
+}
+
+/**
+ * Success result type guard
+ */
+export type SuccessResult<T = void> = Result<T> & {
+  readonly success: true;
+  readonly data: T;
+  readonly error?: never;
+};
+
+/**
+ * Failure result type guard
+ */
+export type FailureResult = Result & {
+  readonly success: false;
+  readonly data?: never;
+  readonly error: ErrorInfo;
+};

package/src/domain/utils/result.util.ts

@@ -1,129 +1,30 @@
 /**
  * Result Utility
- * Unified result type for all operations across auth and firestore modules
- * Provides type-safe success/failure handling
- */
-
-/**
- * Standard error information structure
- */
-export interface ErrorInfo {
-  code: string;
-  message: string;
-}
-
-/**
- * Standard result type for operations
- * Success contains data, failure contains error info
- */
-export interface Result<T = void> {
-  readonly success: boolean;
-  readonly data?: T;
-  readonly error?: ErrorInfo;
-}
-
-/**
- * Success result type guard
- */
-export type SuccessResult<T = void> = Result<T> & { readonly success: true; readonly data: T; readonly error?: never };
-
-/**
- * Failure result type guard
- */
-export type FailureResult = Result & { readonly success: false; readonly data?: never; readonly error: ErrorInfo };
-
-/**
- * Create a success result with optional data
- */
-export function successResult<T = void>(data?: T): SuccessResult<T> {
-  return { success: true, data: data as T };
-}
-
-/**
- * Create a failure result with error information
- */
-export function failureResult(error: ErrorInfo): FailureResult {
-  return { success: false, error };
-}
-
-/**
- * Create a failure result from error code and message
- */
-export function failureResultFrom(code: string, message: string): FailureResult {
-  return { success: false, error: { code, message } };
-}
-
-/**
- * Create a failure result from an unknown error
- */
-export function failureResultFromError(error: unknown, defaultCode = 'operation/failed'): FailureResult {
-  if (error instanceof Error) {
-    return {
-      success: false,
-      error: {
-        code: (error as { code?: string }).code ?? defaultCode,
-        message: error.message,
-      },
-    };
-  }
-  return {
-    success: false,
-    error: {
-      code: defaultCode,
-      message: typeof error === 'string' ? error : 'Unknown error occurred',
-    },
-  };
-}
-
-/**
- * Check if result is successful
- */
-export function isSuccess<T>(result: Result<T>): result is SuccessResult<T> {
-  return result.success === true && result.error === undefined;
-}
-
-/**
- * Check if result is a failure
- */
-export function isFailure<T>(result: Result<T>): result is FailureResult {
-  return result.success === false;
-}
-
-/**
- * Get data from result or return default
- */
-export function getDataOrDefault<T>(result: Result<T>, defaultValue: T): T {
-  return isSuccess(result) ? (result.data ?? defaultValue) : defaultValue;
-}
-
-/**
- * Map success result data to another type
- */
-export function mapResult<T, U>(
-  result: Result<T>,
-  mapper: (data: T) => U
-): Result<U> {
-  if (isSuccess(result) && result.data !== undefined) {
-    return successResult(mapper(result.data));
-  }
-  // Return a new failure result to avoid type conflicts
-  if (isFailure(result)) {
-    return { success: false, error: result.error };
-  }
-  return successResult();
-}
-
-/**
- * Chain multiple results, stopping at first failure
- */
-export async function chainResults<T>(
-  ...operations: (() => Promise<Result<T>>)[]
-): Promise<Result<T>> {
-  for (const operation of operations) {
-    const result = await operation();
-    if (isFailure(result)) {
-      return result;
-    }
-  }
-  return successResult();
-}
+ * Re-exports all result utilities for backward compatibility
+ * @deprecated Import from specific result files instead
+ */
+
+// Types
+export type {
+  ErrorInfo,
+  Result,
+  SuccessResult,
+  FailureResult,
+} from './result/result-types';
+
+// Creators
+export {
+  successResult,
+  failureResult,
+  failureResultFrom,
+  failureResultFromError,
+} from './result/result-creators';
+
+// Helpers
+export {
+  isSuccess,
+  isFailure,
+  getDataOrDefault,
+  mapResult,
+  chainResults,
+} from './result/result-helpers';

package/src/domain/utils/validation.util.ts

@@ -1,211 +1,40 @@
 /**
  * Validation Utility
- * Centralized validation utilities for common patterns
- */
-
-/**
- * Check if a string is a valid non-empty value
- */
-export function isValidString(value: unknown): value is string {
-  return typeof value === 'string' && value.trim().length > 0;
-}
-
-/**
- * Check if a string is empty or whitespace only
- */
-export function isEmptyString(value: unknown): boolean {
-  return typeof value === 'string' && value.trim().length === 0;
-}
-
-/**
- * Validate Firebase API key format
- * Firebase API keys typically start with "AIza" followed by 35 characters
- */
-export function isValidFirebaseApiKey(apiKey: string): boolean {
-  if (!isValidString(apiKey)) {
-    return false;
-  }
-  const apiKeyPattern = /^AIza[0-9A-Za-z_-]{35}$/;
-  return apiKeyPattern.test(apiKey.trim());
-}
-
-/**
- * Validate Firebase authDomain format
- * Expected format: "projectId.firebaseapp.com" or "projectId.web.app"
- */
-export function isValidFirebaseAuthDomain(authDomain: string): boolean {
-  if (!isValidString(authDomain)) {
-    return false;
-  }
-  const trimmed = authDomain.trim();
-  return (
-    trimmed.includes('.firebaseapp.com') ||
-    trimmed.includes('.web.app')
-  );
-}
-
-/**
- * Validate Firebase projectId format
- * Project IDs must be 6-30 characters, lowercase, alphanumeric, and may contain hyphens
- */
-export function isValidFirebaseProjectId(projectId: string): boolean {
-  if (!isValidString(projectId)) {
-    return false;
-  }
-  const pattern = /^[a-z0-9][a-z0-9-]{4,28}[a-z0-9]$/;
-  return pattern.test(projectId.trim());
-}
-
-/**
- * Validate URL format
- */
-export function isValidUrl(url: string): boolean {
-  if (!isValidString(url)) {
-    return false;
-  }
-  try {
-    new URL(url.trim());
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Validate HTTPS URL
- */
-export function isValidHttpsUrl(url: string): boolean {
-  if (!isValidString(url)) {
-    return false;
-  }
-  try {
-    const urlObj = new URL(url.trim());
-    return urlObj.protocol === 'https:';
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Validate email format
- */
-export function isValidEmail(email: string): boolean {
-  if (!isValidString(email)) {
-    return false;
-  }
-  const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-  return emailPattern.test(email.trim());
-}
-
-/**
- * Check if value is defined (not null or undefined)
- */
-export function isDefined<T>(value: T | null | undefined): value is T {
-  return value !== null && value !== undefined;
-}
-
-/**
- * Check if array is not empty
- */
-export function isNonEmptyArray<T>(value: unknown): value is [T, ...T[]] {
-  return Array.isArray(value) && value.length > 0;
-}
-
-/**
- * Check if number is in range
- */
-export function isInRange(value: number, min: number, max: number): boolean {
-  return typeof value === 'number' && value >= min && value <= max;
-}
-
-/**
- * Check if number is positive
- */
-export function isPositive(value: number): boolean {
-  return typeof value === 'number' && value > 0;
-}
-
-/**
- * Check if number is non-negative
- */
-export function isNonNegative(value: number): boolean {
-  return typeof value === 'number' && value >= 0;
-}
-
-/**
- * Validate password strength
- * At least 8 characters, containing uppercase, lowercase, and number
- */
-export function isStrongPassword(password: string): boolean {
-  if (!isValidString(password) || password.length < 8) {
-    return false;
-  }
-  const hasUpperCase = /[A-Z]/.test(password);
-  const hasLowerCase = /[a-z]/.test(password);
-  const hasNumber = /[0-9]/.test(password);
-  return hasUpperCase && hasLowerCase && hasNumber;
-}
-
-/**
- * Validate username format
- * Alphanumeric, underscores, and hyphens, 3-20 characters
- */
-export function isValidUsername(username: string): boolean {
-  if (!isValidString(username)) {
-    return false;
-  }
-  const pattern = /^[a-zA-Z0-9_-]{3,20}$/;
-  return pattern.test(username);
-}
-
-/**
- * Validate phone number format (basic check)
- */
-export function isValidPhoneNumber(phone: string): boolean {
-  if (!isValidString(phone)) {
-    return false;
-  }
-  const cleaned = phone.replace(/\s+/g, '').replace(/[-+()]/g, '');
-  return /^[0-9]{10,15}$/.test(cleaned);
-}
-
-/**
- * Validate object has required properties
- */
-export function hasRequiredProperties<T extends Record<string, unknown>>(
-  obj: unknown,
-  requiredProps: (keyof T)[]
-): obj is T {
-  if (typeof obj !== 'object' || obj === null) {
-    return false;
-  }
-  return requiredProps.every((prop) => prop in obj);
-}
-
-/**
- * Validate all items in array match predicate
- */
-export function allMatch<T>(items: unknown[], predicate: (item: unknown) => item is T): boolean {
-  return Array.isArray(items) && items.every(predicate);
-}
-
-/**
- * Validate at least one item in array matches predicate
- */
-export function anyMatch<T>(items: unknown[], predicate: (item: unknown) => item is T): boolean {
-  return Array.isArray(items) && items.some(predicate);
-}
-
-/**
- * Create a validator that combines multiple validators
- */
-export function combineValidators(...validators: ((value: string) => boolean)[]): (value: string) => boolean {
-  return (value: string) => validators.every((validator) => validator(value));
-}
-
-/**
- * Create a validator that checks if value matches one of validators
- */
-export function anyValidator(...validators: ((value: string) => boolean)[]): (value: string) => boolean {
-  return (value: string) => validators.some((validator) => validator(value));
-}
+ * Re-exports all validators for backward compatibility
+ * @deprecated Import from specific validator files instead
+ */
+
+// String Validators
+export { isValidString, isEmptyString, isDefined } from './validators/string.validator';
+
+// Firebase Validators
+export {
+  isValidFirebaseApiKey,
+  isValidFirebaseAuthDomain,
+  isValidFirebaseProjectId,
+} from './validators/firebase.validator';
+
+// URL Validators
+export { isValidUrl, isValidHttpsUrl } from './validators/url.validator';
+
+// User Input Validators
+export {
+  isValidEmail,
+  isStrongPassword,
+  isValidUsername,
+  isValidPhoneNumber,
+} from './validators/user-input.validator';
+
+// Generic Validators
+export {
+  isNonEmptyArray,
+  isInRange,
+  isPositive,
+  isNonNegative,
+  hasRequiredProperties,
+  allMatch,
+  anyMatch,
+} from './validators/generic.validator';
+
+// Composite Validators
+export { combineValidators, anyValidator } from './validators/composite.validator';

package/src/domain/utils/validators/composite.validator.ts

@@ -0,0 +1,24 @@
+/**
+ * Composite Validators
+ * Higher-order validators for combining multiple validation rules
+ */
+
+/**
+ * Create a validator that combines multiple validators (AND logic)
+ * All validators must pass
+ */
+export function combineValidators(
+  ...validators: ((value: string) => boolean)[]
+): (value: string) => boolean {
+  return (value: string) => validators.every((validator) => validator(value));
+}
+
+/**
+ * Create a validator that checks if value matches one of validators (OR logic)
+ * At least one validator must pass
+ */
+export function anyValidator(
+  ...validators: ((value: string) => boolean)[]
+): (value: string) => boolean {
+  return (value: string) => validators.some((validator) => validator(value));
+}