@umituz/react-native-firebase 2.6.0 → 2.6.2

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

@@ -0,0 +1,150 @@
+/**
+ * Query Options Validation
+ * Single Responsibility: Validate and check query options
+ *
+ * Validation and type checking functionality for QueryOptions.
+ * Separated for better maintainability.
+ *
+ * Max lines: 150 (enforced for maintainability)
+ */
+
+import { QueryOptions } from './QueryOptions';
+
+/**
+ * Validate query options
+ */
+export function validateOptions(options: QueryOptions): { valid: boolean; errors: string[] } {
+  const errors: string[] = [];
+
+  // Validate where clauses
+  for (const clause of options.whereClauses) {
+    const clauseValidation = clause.validate();
+    if (!clauseValidation.valid) {
+      errors.push(...clauseValidation.errors);
+    }
+  }
+
+  // Validate sort options
+  for (const sort of options.sortOptions) {
+    if (!sort.field || typeof sort.field !== 'string') {
+      errors.push('Sort field must be a non-empty string');
+    }
+    if (sort.direction !== 'asc' && sort.direction !== 'desc') {
+      errors.push('Sort direction must be "asc" or "desc"');
+    }
+  }
+
+  // Validate date range
+  if (options.dateRange) {
+    if (!options.dateRange.field || typeof options.dateRange.field !== 'string') {
+      errors.push('Date range field must be a non-empty string');
+    }
+    if (options.dateRange.startDate && !(options.dateRange.startDate instanceof Date)) {
+      errors.push('Start date must be a Date instance');
+    }
+    if (options.dateRange.endDate && !(options.dateRange.endDate instanceof Date)) {
+      errors.push('End date must be a Date instance');
+    }
+    if (
+      options.dateRange.startDate &&
+      options.dateRange.endDate &&
+      options.dateRange.startDate > options.dateRange.endDate
+    ) {
+      errors.push('Start date must be before end date');
+    }
+  }
+
+  // Validate pagination
+  if (options.pagination) {
+    if (options.pagination.limit !== undefined && (typeof options.pagination.limit !== 'number' || options.pagination.limit <= 0)) {
+      errors.push('Pagination limit must be a positive number');
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+  };
+}
+
+/**
+ * Check if has any where clauses
+ */
+export function hasWhereClauses(options: QueryOptions): boolean {
+  return options.whereClauses.length > 0;
+}
+
+/**
+ * Check if has any sort options
+ */
+export function hasSort(options: QueryOptions): boolean {
+  return options.sortOptions.length > 0;
+}
+
+/**
+ * Check if has date range
+ */
+export function hasDateRange(options: QueryOptions): boolean {
+  return options.dateRange !== null;
+}
+
+/**
+ * Check if has pagination
+ */
+export function hasPagination(options: QueryOptions): boolean {
+  return options.pagination !== null;
+}
+
+/**
+ * Check if is empty (no options set)
+ */
+export function isEmpty(options: QueryOptions): boolean {
+  return !hasWhereClauses(options) &&
+         !hasSort(options) &&
+         !hasDateRange(options) &&
+         !hasPagination(options);
+}
+
+/**
+ * Check if options have date range filter
+ */
+export function hasDateFilter(options: QueryOptions): boolean {
+  return hasDateRange(options);
+}
+
+/**
+ * Check if options have limit set
+ */
+export function hasLimit(options: QueryOptions): boolean {
+  return options.pagination?.limit !== undefined;
+}
+
+/**
+ * Check if options have cursor set
+ */
+export function hasCursor(options: QueryOptions): boolean {
+  return options.pagination?.cursor !== undefined;
+}
+
+/**
+ * Check if options are valid for compound queries
+ */
+export function isValidForCompoundQuery(options: QueryOptions): boolean {
+  // Check for array/membership operator conflicts
+  const arrayCount = options.whereClauses.filter(c => c.isArrayOperator() || c.isMembership()).length;
+
+  if (arrayCount > 1) {
+    return false;
+  }
+
+  return validateOptions(options).valid;
+}
+
+/**
+ * Check if options are ready for execution
+ */
+export function isReadyToExecute(options: QueryOptions): boolean {
+  if (!validateOptions(options).valid) {
+    return false;
+  }
+

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

@@ -0,0 +1,32 @@
+  // Must have at least one filter
+  if (isEmpty(options)) {
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Get query options type
+ */
+export function getQueryType(options: QueryOptions): 'empty' | 'simple' | 'complex' {
+  if (isEmpty(options)) {
+    return 'empty';
+  }
+
+  const complexity = options.whereClauses.length + options.sortOptions.length;
+
+  if (complexity <= 2) {
+    return 'simple';
+  }
+
+  return 'complex';
+}
+
+/**
+ * Check if query is read-only (no modifications needed)
+ */
+export function isReadOnly(options: QueryOptions): boolean {
+  // Query options are always read-only
+  return true;
+}

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

@@ -0,0 +1,150 @@
+/**
+ * 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

@@ -0,0 +1,41 @@
+   */
+  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

@@ -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);
+  }
+}