@umituz/react-native-firebase 2.5.1 → 2.6.1

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

@@ -0,0 +1,299 @@
+/**
+ * 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`);
+      }
+    }
+
+    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/domains/firestore/domain/value-objects/WhereClauseFactory.ts

@@ -0,0 +1,207 @@
+/**
+ * Where Clause Factory
+ * Single Responsibility: Provide factory methods for common where clauses
+ *
+ * Factory functions for creating commonly used where clauses.
+ * Separated from WhereClause for better maintainability.
+ *
+ * Max lines: 150 (enforced for maintainability)
+ */
+
+import type { WhereFilterOp } from 'firebase/firestore';
+import { WhereClause } from './WhereClause';
+import type { WhereOperator } from './WhereClause';
+
+/**
+ * Factory function to create where clause
+ */
+export function createWhereClause(
+  field: string,
+  operator: WhereFilterOp,
+  value: unknown
+): WhereClause {
+  return WhereClause.create(field, operator, value);
+}
+
+/**
+ * Factory functions for common where clauses
+ */
+export const where = {
+  equals: WhereClause.equals,
+  notEquals: WhereClause.notEquals,
+  lessThan: WhereClause.lessThan,
+  lessThanOrEqual: WhereClause.lessThanOrEqual,
+  greaterThan: WhereClause.greaterThan,
+  greaterThanOrEqual: WhereClause.greaterThanOrEqual,
+  arrayContains: WhereClause.arrayContains,
+  arrayContainsAny: WhereClause.arrayContainsAny,
+  in: WhereClause.in,
+  notIn: WhereClause.notIn,
+};
+
+/**
+ * Create batch of where clauses
+ */
+export function createWhereBatch(
+  clauses: Array<{ field: string; operator: WhereFilterOp; value: unknown }>
+): WhereClause[] {
+  return clauses.map(c => WhereClause.create(c.field, c.operator, c.value));
+}
+
+/**
+ * Create equality clauses from object
+ */
+export function createEqualityFilters(obj: Record<string, unknown>): WhereClause[] {
+  return Object.entries(obj).map(([field, value]) =>
+    WhereClause.equals(field, value)
+  );
+}
+
+/**
+ * Create in clause from values
+ */
+export function createInClause(field: string, values: unknown[]): WhereClause {
+  return WhereClause.in(field, values);
+}
+
+/**
+ * Create not-in clause from values
+ */
+export function createNotInClause(field: string, values: unknown[]): WhereClause {
+  return WhereClause.notIn(field, values);
+}
+
+/**
+ * Create range clause (>= start and <= end)
+ */
+export function createRangeClause(
+  field: string,
+  startValue: unknown,
+  endValue: unknown
+): WhereClause[] {
+  return [
+    WhereClause.greaterThanOrEqual(field, startValue),
+    WhereClause.lessThanOrEqual(field, endValue),
+  ];
+}
+
+/**
+ * Create date range clause
+ */
+export function createDateRangeClause(
+  field: string,
+  startDate: Date,
+  endDate: Date
+): WhereClause[] {
+  return createRangeClause(field, startDate, endDate);
+}
+
+/**
+ * Create text search clause (case-insensitive contains)
+ * Note: Firestore doesn't support native contains, this is for consistency
+ */
+export function createTextSearchClause(field: string, searchText: string): WhereClause {
+  return WhereClause.equals(field, searchText);
+}
+
+/**
+ * Create multiple equality clauses combined
+ */
+export function createMultiFieldFilter(filters: Record<string, unknown>): WhereClause[] {
+  return createEqualityFilters(filters);
+}
+
+/**
+ * Create not-null clause
+ */
+export function createNotNullClause(field: string): WhereClause {
+  return WhereClause.notEquals(field, null);
+}
+
+/**
+ * Create null clause
+ */
+export function createNullClause(field: string): WhereClause {
+  return WhereClause.equals(field, null);
+}
+
+/**
+ * Create boolean clause
+ */
+export function createBooleanClause(field: string, value: boolean): WhereClause {
+  return WhereClause.equals(field, value);
+}
+
+/**
+ * Create number range clause
+ */
+export function createNumberRangeClause(
+  field: string,
+  min: number,
+  max: number
+): WhereClause[] {
+  return [
+    WhereClause.greaterThanOrEqual(field, min),
+    WhereClause.lessThanOrEqual(field, max),
+  ];
+}
+
+/**
+ * Validate where clauses compatibility
+ */
+export function validateWhereClauses(clauses: WhereClause[]): {
+  valid: boolean;
+  errors: string[];
+} {
+  const errors: string[] = [];
+
+  // Validate each clause individually
+  for (let i = 0; i < clauses.length; i++) {
+    const validation = clauses[i].validate();
+    if (!validation.valid) {
+      errors.push(`Clause ${i}: ${validation.errors.join(', ')}`);
+    }
+  }
+
+  // Validate compatibility
+  for (let i = 0; i < clauses.length; i++) {
+    for (let j = i + 1; j < clauses.length; j++) {
+      if (!clauses[i].isCompatibleWith(clauses[j])) {
+        errors.push(`Clauses ${i} and ${j} are incompatible`);
+      }
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+  };
+}
+
+/**
+ * Optimize where clauses
+ * Removes duplicates and incompatible clauses
+ */
+export function optimizeWhereClauses(clauses: WhereClause[]): WhereClause[] {
+  // Remove duplicates
+  const unique = clauses.filter((clause, index, self) =>
+    index === self.findIndex(c => clause.equals(c))
+  );
+
+  // Remove incompatible (keep first occurrences)
+  const compatible: WhereClause[] = [];
+  for (const clause of unique) {
+    let canAdd = true;
+    for (const existing of compatible) {
+      if (!clause.isCompatibleWith(existing)) {
+        canAdd = false;
+        break;
+      }
+    }
+    if (canAdd) {
+      compatible.push(clause);
+    }
+  }
+
+  return compatible;
+}

package/src/domains/firestore/index.ts

@@ -3,12 +3,15 @@
  * Domain-Driven Design (DDD) Architecture
  */
 
-// Domain Errors
-export {
-  FirebaseFirestoreError,
-  FirebaseFirestoreInitializationError,
-  FirebaseFirestoreQuotaError,
-} from './domain/errors/FirebaseFirestoreError';
+// =============================================================================
+// DOMAIN LAYER - Business Logic
+// =============================================================================
+
+export * from './domain';
+
+// =============================================================================
+// INFRASTRUCTURE LAYER - Implementation
+// =============================================================================
 
 // Firestore Client
 export {
@@ -100,5 +103,16 @@ export type { UseFirestoreQueryOptions } from './presentation/hooks/useFirestore
 export type { UseFirestoreMutationOptions } from './presentation/hooks/useFirestoreMutation';
 export type { UseFirestoreSnapshotOptions } from './presentation/hooks/useFirestoreSnapshot';
 
+// Re-export commonly used Firebase Firestore types
+export type {
+  Timestamp,
+  DocumentSnapshot,
+  QuerySnapshot,
+  DocumentReference,
+  CollectionReference,
+  Query,
+  Transaction,
+} from 'firebase/firestore';
+
 // Firebase types are available from the 'firebase' package directly
 // Import them in your app: import { Timestamp } from 'firebase/firestore';

package/src/index.ts

@@ -46,6 +46,31 @@ export {
   getSafeErrorCode,
 } from "./shared/domain/guards/firebase-error.guard";
 
+// Shared Infrastructure Base Classes
+export {
+  ServiceBase,
+  ErrorHandler,
+  defaultErrorHandler,
+  hasCodeProperty,
+  hasMessageProperty,
+  isFirebaseErrorLike,
+  hasNameProperty,
+  isErrorLike,
+  hasUidProperty,
+  hasEmailProperty,
+  hasProviderIdProperty,
+  isArray,
+  isString,
+  isFunction,
+  hasProperty,
+  hasProperties,
+} from "./shared/infrastructure/base";
+
+export type {
+  ServiceBaseOptions,
+  ErrorHandlerOptions,
+} from "./shared/infrastructure/base";
+
 // Domain Exports
 export * from "./domains/auth";
 export * from "./domains/account-deletion";