@umituz/react-native-firebase 2.6.3 → 2.6.4

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

@@ -1,150 +0,0 @@
-/**
- * Query Options Value Object (Main)
- * Single Responsibility: Encapsulate query configuration options
- *
- * Value object that represents query options in a type-safe way.
- * Provides validation and business logic for query configuration.
- *
- * Max lines: 150 (enforced for maintainability)
- */
-
-import type { WhereFilterOp, OrderByDirection } from 'firebase/firestore';
-import { WhereClause } from './WhereClause';
-
-/**
- * Sort options
- */
-export interface SortOptions {
-  readonly field: string;
-  readonly direction: OrderByDirection;
-}
-
-/**
- * Date range options
- */
-export interface DateRangeOptions {
-  readonly field: string;
-  readonly startDate?: Date;
-  readonly endDate?: Date;
-}
-
-/**
- * Pagination options
- */
-export interface PaginationOptions {
-  readonly cursor?: number;
-  readonly limit?: number;
-  readonly startAfter?: number;
-  readonly startAt?: number;
-}
-
-/**
- * Query options value object
- * Immutable configuration for Firestore queries
- */
-export class QueryOptions {
-  readonly whereClauses: readonly WhereClause[];
-  readonly sortOptions: readonly SortOptions[];
-  readonly dateRange: DateRangeOptions | null;
-  readonly pagination: PaginationOptions | null;
-
-  private constructor(
-    whereClauses: WhereClause[],
-    sortOptions: SortOptions[],
-    dateRange: DateRangeOptions | null,
-    pagination: PaginationOptions | null
-  ) {
-    this.whereClauses = Object.freeze(whereClauses);
-    this.sortOptions = Object.freeze(sortOptions);
-    this.dateRange = dateRange ? Object.freeze(dateRange) : null;
-    this.pagination = pagination ? Object.freeze(pagination) : null;
-  }
-
-  /**
-   * Create empty query options
-   */
-  static empty(): QueryOptions {
-    return new QueryOptions([], [], null, null);
-  }
-
-  /**
-   * Create query options from partial configuration
-   */
-  static create(options: {
-    where?: WhereClause[];
-    sort?: SortOptions[];
-    dateRange?: DateRangeOptions;
-    pagination?: PaginationOptions;
-  }): QueryOptions {
-    return new QueryOptions(
-      options.where || [],
-      options.sort || [],
-      options.dateRange || null,
-      options.pagination || null
-    );
-  }
-
-  /**
-   * Add where clause
-   */
-  withWhere(clause: WhereClause): QueryOptions {
-    return new QueryOptions(
-      [...this.whereClauses, clause] as WhereClause[],
-      this.sortOptions,
-      this.dateRange,
-      this.pagination
-    );
-  }
-
-  /**
-   * Add sort option
-   */
-  withSort(sort: SortOptions): QueryOptions {
-    return new QueryOptions(
-      this.whereClauses,
-      [...this.sortOptions, sort] as SortOptions[],
-      this.dateRange,
-      this.pagination
-    );
-  }
-
-  /**
-   * Set date range
-   */
-  withDateRange(dateRange: DateRangeOptions): QueryOptions {
-    return new QueryOptions(
-      this.whereClauses,
-      this.sortOptions,
-      dateRange,
-      this.pagination
-    );
-  }
-
-  /**
-   * Set pagination
-   */
-  withPagination(pagination: PaginationOptions): QueryOptions {
-    return new QueryOptions(
-      this.whereClauses,
-      this.sortOptions,
-      this.dateRange,
-      pagination
-    );
-  }
-
-  /**
-   * Remove all where clauses
-   */
-  clearWhere(): QueryOptions {
-    return new QueryOptions([], this.sortOptions, this.dateRange, this.pagination);
-  }
-
-  /**
-   * Remove all sort options
-   */
-  clearSort(): QueryOptions {
-    return new QueryOptions(this.whereClauses, [], this.dateRange, this.pagination);
-  }
-
-  /**
-   * Remove date range

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

@@ -1,41 +0,0 @@
-   */
-  clearDateRange(): QueryOptions {
-    return new QueryOptions(this.whereClauses, this.sortOptions, null, this.pagination);
-  }
-
-  /**
-   * Remove pagination
-   */
-  clearPagination(): QueryOptions {
-    return new QueryOptions(this.whereClauses, this.sortOptions, this.dateRange, null);
-  }
-
-  /**
-   * Clone with modifications
-   */
-  clone(modifications: {
-    where?: WhereClause[];
-    sort?: SortOptions[];
-    dateRange?: DateRangeOptions | null;
-    pagination?: PaginationOptions | null;
-  }): QueryOptions {
-    return QueryOptions.create({
-      where: modifications.where ?? [...this.whereClauses] as WhereClause[],
-      sort: modifications.sort ?? [...this.sortOptions] as SortOptions[],
-      dateRange: modifications.dateRange ?? this.dateRange ?? null,
-      pagination: modifications.pagination ?? this.pagination ?? null,
-    });
-  }
-}
-
-/**
- * Factory function to create query options
- */
-export function createQueryOptions(options?: {
-  where?: WhereClause[];
-  sort?: SortOptions[];
-  dateRange?: DateRangeOptions;
-  pagination?: PaginationOptions;
-}): QueryOptions {
-  return options ? QueryOptions.create(options) : QueryOptions.empty();
-}

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

@@ -1,299 +0,0 @@
-/**
- * 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.bak

@@ -1,207 +0,0 @@
-/**
- * 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;
-}