@umituz/react-native-firebase 2.6.1 → 2.6.3

package/src/domains/firestore/domain/value-objects/WhereClauseHelpers.ts

@@ -0,0 +1,123 @@
+/**
+ * Where Clause Helper Utilities
+ * Single Responsibility: Provide helper functions for where clauses
+ *
+ * Max lines: 150 (enforced for maintainability)
+ */
+
+import type { WhereFilterOp } from 'firebase/firestore';
+import type { WhereClause } from './WhereClause';
+import {
+  isEqualityOperator,
+  isInequalityOperator,
+  isComparisonOperator,
+  isArrayOperator,
+  isMembershipOperator,
+} from './WhereClauseValidation';
+
+/**
+ * Get field path as array
+ */
+export function getFieldPath(clause: WhereClause): string[] {
+  return clause.field.split('.');
+}
+
+/**
+ * Check if field is nested
+ */
+export function isNestedField(clause: WhereClause): boolean {
+  return clause.field.includes('.');
+}
+
+/**
+ * Get top-level field name
+ */
+export function getTopLevelField(clause: WhereClause): string {
+  const parts = clause.field.split('.');
+  return parts[0] || '';
+}
+
+/**
+ * Get description of where clause
+ */
+export function getDescription(clause: WhereClause): string {
+  return `${clause.field} ${clause.operator} ${JSON.stringify(clause.value)}`;
+}
+
+/**
+ * Convert where clause to object
+ */
+export function toObject(clause: WhereClause): {
+  field: string;
+  operator: WhereFilterOp;
+  value: unknown;
+} {
+  return {
+    field: clause.field,
+    operator: clause.operator,
+    value: clause.value,
+  };
+}
+
+/**
+ * Check if two where clauses are equal
+ */
+export function whereClausesEqual(a: WhereClause, b: WhereClause): boolean {
+  return (
+    a.field === b.field &&
+    a.operator === b.operator &&
+    JSON.stringify(a.value) === JSON.stringify(b.value)
+  );
+}
+
+/**
+ * Check if where clauses are compatible (can be used together)
+ */
+export function areClausesCompatible(a: WhereClause, b: WhereClause): boolean {
+  // Same field with different operators is not allowed
+  if (a.field === b.field && a.operator !== b.operator) {
+    return false;
+  }
+
+  // Inequality operators cannot be combined with other inequality operators on same field
+  if (a.field === b.field && isInequalityOperator(a.operator) && isInequalityOperator(b.operator)) {
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Check if clause is equality type
+ */
+export function isEqualityClause(clause: WhereClause): boolean {
+  return isEqualityOperator(clause.operator);
+}
+
+/**
+ * Check if clause is inequality type
+ */
+export function isInequalityClause(clause: WhereClause): boolean {
+  return isInequalityOperator(clause.operator);
+}
+
+/**
+ * Check if clause is comparison type
+ */
+export function isComparisonClause(clause: WhereClause): boolean {
+  return isComparisonOperator(clause.operator);
+}
+
+/**
+ * Check if clause is array type
+ */
+export function isArrayClause(clause: WhereClause): boolean {
+  return isArrayOperator(clause.operator);
+}
+
+/**
+ * Check if clause is membership type
+ */
+export function isMembershipClause(clause: WhereClause): boolean {
+  return isMembershipOperator(clause.operator);
+}

package/src/domains/firestore/domain/value-objects/WhereClauseValidation.ts

@@ -0,0 +1,83 @@
+/**
+ * Where Clause Validation Utilities
+ * Single Responsibility: Validate where clauses
+ *
+ * Max lines: 150 (enforced for maintainability)
+ */
+
+import type { WhereFilterOp } from 'firebase/firestore';
+import type { WhereClause } from './WhereClause';
+
+/**
+ * Validate where clause
+ */
+export function validateWhereClause(clause: WhereClause): {
+  valid: boolean;
+  errors: string[];
+} {
+  const errors: string[] = [];
+
+  // Field validation
+  if (!clause.field || clause.field.trim() === '') {
+    errors.push('Field cannot be empty');
+  }
+
+  // Value validation
+  if (clause.value === undefined) {
+    errors.push('Value cannot be undefined');
+  }
+
+  // Operator-specific validation
+  if (requiresArrayValue(clause.operator)) {
+    if (!Array.isArray(clause.value)) {
+      errors.push(`Operator '${clause.operator}' requires an array value`);
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+  };
+}
+
+/**
+ * Check if operator requires array value
+ */
+export function requiresArrayValue(operator: WhereFilterOp): boolean {
+  return operator === 'in' || operator === 'not-in' || operator === 'array-contains-any';
+}
+
+/**
+ * Check if operator is equality type
+ */
+export function isEqualityOperator(operator: WhereFilterOp): boolean {
+  return operator === '==';
+}
+
+/**
+ * Check if operator is inequality type
+ */
+export function isInequalityOperator(operator: WhereFilterOp): boolean {
+  return operator === '!=';
+}
+
+/**
+ * Check if operator is comparison type
+ */
+export function isComparisonOperator(operator: WhereFilterOp): boolean {
+  return ['<', '<=', '>', '>='].includes(operator);
+}
+
+/**
+ * Check if operator is array type
+ */
+export function isArrayOperator(operator: WhereFilterOp): boolean {
+  return operator === 'array-contains' || operator === 'array-contains-any';
+}
+
+/**
+ * Check if operator is membership type
+ */
+export function isMembershipOperator(operator: WhereFilterOp): boolean {
+  return operator === 'in' || operator === 'not-in';
+}

package/src/domains/firestore/domain/value-objects/WhereClause_part_aa

@@ -0,0 +1,150 @@
+/**
+ * Where Clause Value Object
+ * Single Responsibility: Encapsulate where clause conditions
+ *
+ * Value object that represents a single where clause condition.
+ * Provides validation and business logic for query filtering.
+ *
+ * Max lines: 150 (enforced for maintainability)
+ */
+
+import type { WhereFilterOp } from 'firebase/firestore';
+
+/**
+ * Valid where operators for Firestore queries
+ */
+export type WhereOperator =
+  | '=='
+  | '!='
+  | '<'
+  | '<='
+  | '>'
+  | '>='
+  | 'array-contains'
+  | 'array-contains-any'
+  | 'in'
+  | 'not-in';
+
+/**
+ * Where clause value object
+ * Immutable representation of a single query condition
+ */
+export class WhereClause {
+  readonly field: string;
+  readonly operator: WhereFilterOp;
+  readonly value: unknown;
+
+  private constructor(field: string, operator: WhereFilterOp, value: unknown) {
+    this.field = field;
+    this.operator = operator;
+    this.value = Object.freeze(value);
+  }
+
+  /**
+   * Create a where clause
+   */
+  static create(field: string, operator: WhereFilterOp, value: unknown): WhereClause {
+    return new WhereClause(field, operator, value);
+  }
+
+  /**
+   * Create equality clause (==)
+   */
+  static equals(field: string, value: unknown): WhereClause {
+    return new WhereClause(field, '==', value);
+  }
+
+  /**
+   * Create inequality clause (!=)
+   */
+  static notEquals(field: string, value: unknown): WhereClause {
+    return new WhereClause(field, '!=', value);
+  }
+
+  /**
+   * Create less than clause (<)
+   */
+  static lessThan(field: string, value: unknown): WhereClause {
+    return new WhereClause(field, '<', value);
+  }
+
+  /**
+   * Create less than or equal clause (<=)
+   */
+  static lessThanOrEqual(field: string, value: unknown): WhereClause {
+    return new WhereClause(field, '<=', value);
+  }
+
+  /**
+   * Create greater than clause (>)
+   */
+  static greaterThan(field: string, value: unknown): WhereClause {
+    return new WhereClause(field, '>', value);
+  }
+
+  /**
+   * Create greater than or equal clause (>=)
+   */
+  static greaterThanOrEqual(field: string, value: unknown): WhereClause {
+    return new WhereClause(field, '>=', value);
+  }
+
+  /**
+   * Create array contains clause
+   */
+  static arrayContains(field: string, value: unknown): WhereClause {
+    return new WhereClause(field, 'array-contains', value);
+  }
+
+  /**
+   * Create array contains any clause
+   */
+  static arrayContainsAny(field: string, values: unknown[]): WhereClause {
+    return new WhereClause(field, 'array-contains-any', values);
+  }
+
+  /**
+   * Create in clause
+   */
+  static in(field: string, values: unknown[]): WhereClause {
+    return new WhereClause(field, 'in', values);
+  }
+
+  /**
+   * Create not-in clause
+   */
+  static notIn(field: string, values: unknown[]): WhereClause {
+    return new WhereClause(field, 'not-in', values);
+  }
+
+  /**
+   * Validate where clause
+   */
+  validate(): { valid: boolean; errors: string[] } {
+    const errors: string[] = [];
+
+    // Validate field name
+    if (!this.field || typeof this.field !== 'string' || this.field.trim() === '') {
+      errors.push('Field name must be a non-empty string');
+    }
+
+    // Validate operator
+    const validOperators: WhereFilterOp[] = [
+      '==', '!=', '<', '<=', '>', '>=',
+      'array-contains', 'array-contains-any', 'in', 'not-in'
+    ];
+    if (!validOperators.includes(this.operator)) {
+      errors.push(`Invalid operator: ${this.operator}`);
+    }
+
+    // Validate value based on operator
+    if (this.operator === 'array-contains-any' || this.operator === 'in' || this.operator === 'not-in') {
+      if (!Array.isArray(this.value)) {
+        errors.push(`Operator ${this.operator} requires an array value`);
+      } else if (this.value.length === 0) {
+        errors.push(`Operator ${this.operator} requires a non-empty array`);
+      } else if (this.value.length > 10) {
+        errors.push(`Operator ${this.operator} supports maximum 10 elements`);
+      }
+    }
+

package/src/domains/firestore/domain/value-objects/WhereClause_part_ab

@@ -0,0 +1,149 @@
+    return {
+      valid: errors.length === 0,
+      errors,
+    };
+  }
+
+  /**
+   * Check if equals another where clause
+   */
+  equals(other: WhereClause): boolean {
+    return (
+      this.field === other.field &&
+      this.operator === other.operator &&
+      JSON.stringify(this.value) === JSON.stringify(other.value)
+    );
+  }
+
+  /**
+   * Check if compatible for compound queries
+   * Some operator combinations are not allowed in Firestore
+   */
+  isCompatibleWith(other: WhereClause): boolean {
+    // Equality and inequality operators can be combined
+    // Array operators and membership operators have restrictions
+    if (
+      (this.isArrayOperator() || this.isMembership()) &&
+      (other.isArrayOperator() || other.isMembership())
+    ) {
+      // Only one array/membership clause per query
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Get field path components
+   * Returns array of field path segments (for nested fields)
+   */
+  getFieldPath(): string[] {
+    return this.field.split('.');
+  }
+
+  /**
+   * Check if field is nested (contains dots)
+   */
+  isNestedField(): boolean {
+    return this.field.includes('.');
+  }
+
+  /**
+   * Get top-level field name
+   */
+  getTopLevelField(): string {
+    return this.getFieldPath()[0];
+  }
+
+  /**
+   * Get human-readable description
+   */
+  getDescription(): string {
+    const valueStr = Array.isArray(this.value)
+      ? `[${this.value.map(v => JSON.stringify(v)).join(', ')}]`
+      : JSON.stringify(this.value);
+
+    return `${this.field} ${this.operator} ${valueStr}`;
+  }
+
+  /**
+   * Convert to plain object (for serialization)
+   */
+  toObject(): { field: string; operator: WhereFilterOp; value: unknown } {
+    return {
+      field: this.field,
+      operator: this.operator,
+      value: this.value,
+    };
+  }
+
+  /**
+   * Create from plain object
+   */
+  static fromObject(obj: { field: string; operator: WhereFilterOp; value: unknown }): WhereClause {
+    return WhereClause.create(obj.field, obj.operator, obj.value);
+  }
+
+  /**
+   * Clone with new value
+   */
+  withValue(newValue: unknown): WhereClause {
+    return new WhereClause(this.field, this.operator, newValue);
+  }
+
+  /**
+   * Clone with new field
+   */
+  withField(newField: string): WhereClause {
+    return new WhereClause(newField, this.operator, this.value);
+  }
+
+  /**
+   * Clone with new operator
+   */
+  withOperator(newOperator: WhereFilterOp): WhereClause {
+    return new WhereClause(this.field, newOperator, this.value);
+  }
+
+  /**
+   * Check if is equality operator
+   */
+  isEquality(): boolean {
+    return this.operator === '==';
+  }
+
+  /**
+   * Check if is inequality operator
+   */
+  isInequality(): boolean {
+    return this.operator === '!=';
+  }
+
+  /**
+   * Check if is comparison operator (<, <=, >, >=)
+   */
+  isComparison(): boolean {
+    return ['<', '<=', '>', '>='].includes(this.operator);
+  }
+
+  /**
+   * Check if is array operator
+   */
+  isArrayOperator(): boolean {
+    return ['array-contains', 'array-contains-any'].includes(this.operator);
+  }
+
+  /**
+   * Check if is membership operator (in, not-in)
+   */
+  isMembership(): boolean {
+    return ['in', 'not-in'].includes(this.operator);
+  }
+
+  /**
+   * Check if operator requires array value
+   */
+  requiresArrayValue(): boolean {
+    return ['array-contains-any', 'in', 'not-in'].includes(this.operator);
+  }
+}

package/src/shared/infrastructure/base/ErrorHandler_part_aa

@@ -0,0 +1,150 @@
+/**
+ * Error Handler Base Class
+ * Single Responsibility: Centralized error handling and conversion
+ *
+ * Eliminates try-catch duplication across 9+ files.
+ * Provides standardized error-to-ErrorInfo conversion.
+ * Integrates with existing Result pattern.
+ *
+ * Max lines: 150 (enforced for maintainability)
+ */
+
+import type { ErrorInfo } from '../../domain/utils';
+import { toErrorInfo, successResult, type Result } from '../../domain/utils';
+import { isCancelledError, isQuotaError, isRetryableError } from '../../domain/utils/error-handlers/error-checkers';
+import { ERROR_MESSAGES } from '../../domain/utils/error-handlers/error-messages';
+
+/**
+ * Error handler options
+ */
+export interface ErrorHandlerOptions {
+  /** Default error code if none can be extracted */
+  defaultErrorCode?: string;
+  /** Custom error message mapper */
+  errorMapper?: (error: unknown) => string | null;
+  /** Enable detailed logging in development */
+  enableDevLogging?: boolean;
+}
+
+/**
+ * Base class for error handling
+ * Provides centralized error conversion and handling
+ */
+export class ErrorHandler {
+  private readonly options: ErrorHandlerOptions;
+
+  constructor(options: ErrorHandlerOptions = {}) {
+    this.options = {
+      defaultErrorCode: 'unknown/error',
+      enableDevLogging: __DEV__,
+      ...options,
+    };
+  }
+
+  /**
+   * Wrap an async operation with standardized error handling
+   * Eliminates try-catch duplication across services
+   */
+  async handleAsync<T>(
+    operation: () => Promise<T>,
+    errorCode: string = this.options.defaultErrorCode || 'unknown/error'
+  ): Promise<Result<T>> {
+    try {
+      const result = await operation();
+      return successResult(result);
+    } catch (error) {
+      if (this.options.enableDevLogging) {
+        console.error(`[ErrorHandler] Operation failed: ${errorCode}`, error);
+      }
+      return { success: false, error: toErrorInfo(error, errorCode) };
+    }
+  }
+
+  /**
+   * Wrap a synchronous operation with standardized error handling
+   */
+  handle<T>(
+    operation: () => T,
+    errorCode: string = this.options.defaultErrorCode || 'unknown/error'
+  ): Result<T> {
+    try {
+      const result = operation();
+      return successResult(result);
+    } catch (error) {
+      if (this.options.enableDevLogging) {
+        console.error(`[ErrorHandler] Operation failed: ${errorCode}`, error);
+      }
+      return { success: false, error: toErrorInfo(error, errorCode) };
+    }
+  }
+
+  /**
+   * Convert error to ErrorInfo with optional custom code
+   */
+  toErrorInfo(error: unknown, code?: string): ErrorInfo {
+    // Try custom error mapper first
+    if (this.options.errorMapper) {
+      const customMessage = this.options.errorMapper(error);
+      if (customMessage) {
+        return {
+          code: code || this.options.defaultErrorCode || 'unknown/error',
+          message: customMessage,
+        };
+      }
+    }
+
+    // Use standard conversion
+    return toErrorInfo(error, code || this.options.defaultErrorCode);
+  }
+
+  /**
+   * Check if error is a cancelled operation
+   */
+  isCancelledError(error: unknown): boolean {
+    return isCancelledError(error);
+  }
+
+  /**
+   * Check if error is a quota error
+   */
+  isQuotaError(error: unknown): boolean {
+    return isQuotaError(error);
+  }
+
+  /**
+   * Check if error is retryable
+   */
+  isRetryableError(error: unknown): boolean {
+    return isRetryableError(error);
+  }
+
+  /**
+   * Get user-friendly error message
+   * Maps error codes to user-friendly messages
+   */
+  getUserMessage(error: ErrorInfo): string {
+    // Check if it's a known error category
+    if (error.code.startsWith('auth/')) {
+      return this.getAuthUserMessage(error.code);
+    }
+    if (error.code.startsWith('firestore/')) {
+      return this.getFirestoreUserMessage(error.code);
+    }
+    if (error.code.startsWith('storage/')) {
+      return ERROR_MESSAGES.STORAGE.GENERIC_ERROR;
+    }
+
+    return error.message || ERROR_MESSAGES.GENERAL.UNKNOWN;
+  }
+
+  /**
+   * Get user-friendly auth error message
+   */
+  private getAuthUserMessage(code: string): string {
+    // Map common auth error codes to user-friendly messages
+    const authMessages: Record<string, string> = {
+      'auth/user-not-found': ERROR_MESSAGES.AUTH.USER_NOT_FOUND,
+      'auth/wrong-password': ERROR_MESSAGES.AUTH.INVALID_CREDENTIALS,
+      'auth/email-already-in-use': ERROR_MESSAGES.AUTH.EMAIL_ALREADY_IN_USE,
+      'auth/invalid-email': ERROR_MESSAGES.AUTH.INVALID_EMAIL,
+      'auth/weak-password': ERROR_MESSAGES.AUTH.WEAK_PASSWORD,

package/src/shared/infrastructure/base/ErrorHandler_part_ab

@@ -0,0 +1,39 @@
+      'auth/too-many-requests': ERROR_MESSAGES.AUTH.TOO_MANY_REQUESTS,
+      'auth/user-disabled': ERROR_MESSAGES.AUTH.USER_DISABLED,
+    };
+
+    return authMessages[code] || ERROR_MESSAGES.AUTH.GENERIC_ERROR;
+  }
+
+  /**
+   * Get user-friendly firestore error message
+   */
+  private getFirestoreUserMessage(code: string): string {
+    const firestoreMessages: Record<string, string> = {
+      'firestore/permission-denied': ERROR_MESSAGES.FIRESTORE.PERMISSION_DENIED,
+      'firestore/not-found': ERROR_MESSAGES.FIRESTORE.NOT_FOUND,
+      'firestore/unavailable': ERROR_MESSAGES.FIRESTORE.UNAVAILABLE,
+    };
+
+    return firestoreMessages[code] || ERROR_MESSAGES.FIRESTORE.GENERIC_ERROR;
+  }
+
+  /**
+   * Create a failure result from error code
+   */
+  failureFrom(code: string, message?: string): Result {
+    return {
+      success: false,
+      error: {
+        code,
+        message: message || ERROR_MESSAGES.GENERAL.UNKNOWN,
+      },
+    };
+  }
+}
+
+/**
+ * Default error handler instance
+ * Can be used across the application
+ */
+export const defaultErrorHandler = new ErrorHandler();