@umituz/react-native-firebase 3.0.3 → 3.0.5

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

@@ -1,143 +0,0 @@
-/**
- * Query Options Value Object (Main)
- * Single Responsibility: Encapsulate query configuration options
- *
- * Max lines: 150 (enforced for maintainability)
- */
-
-import type { OrderByDirection } from 'firebase/firestore';
-import { WhereClause } from './WhereClause';
-import * as Factory from './QueryOptionsFactory';
-
-export interface SortOptions {
-  readonly field: string;
-  readonly direction: OrderByDirection;
-}
-
-export interface DateRangeOptions {
-  readonly field: string;
-  readonly startDate?: Date;
-  readonly endDate?: Date;
-}
-
-export interface PaginationOptions {
-  readonly cursor?: number;
-  readonly limit?: number;
-  readonly startAfter?: number;
-  readonly startAt?: number;
-}
-
-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;
-  }
-
-  static empty(): QueryOptions {
-    return new QueryOptions([], [], null, null);
-  }
-
-  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
-    );
-  }
-
-  withWhere(clause: WhereClause): QueryOptions {
-    return new QueryOptions(
-      [...this.whereClauses, clause] as WhereClause[],
-      [...this.sortOptions] as SortOptions[],
-      this.dateRange,
-      this.pagination
-    );
-  }
-
-  withSort(sort: SortOptions): QueryOptions {
-    return new QueryOptions(
-      [...this.whereClauses] as WhereClause[],
-      [...this.sortOptions, sort] as SortOptions[],
-      this.dateRange,
-      this.pagination
-    );
-  }
-
-  withDateRange(dateRange: DateRangeOptions): QueryOptions {
-    return new QueryOptions(
-      [...this.whereClauses] as WhereClause[],
-      [...this.sortOptions] as SortOptions[],
-      dateRange,
-      this.pagination
-    );
-  }
-
-  withPagination(pagination: PaginationOptions): QueryOptions {
-    return new QueryOptions(
-      [...this.whereClauses] as WhereClause[],
-      [...this.sortOptions] as SortOptions[],
-      this.dateRange,
-      pagination
-    );
-  }
-
-  withLimit(limit: number): QueryOptions {
-    return this.withPagination({
-      ...this.pagination,
-      limit,
-    } as PaginationOptions);
-  }
-
-  clearWhere(): QueryOptions {
-    return new QueryOptions([], [...this.sortOptions] as SortOptions[], this.dateRange, this.pagination);
-  }
-
-  clearSort(): QueryOptions {
-    return new QueryOptions([...this.whereClauses] as WhereClause[], [], this.dateRange, this.pagination);
-  }
-
-  clearDateRange(): QueryOptions {
-    return new QueryOptions([...this.whereClauses] as WhereClause[], [...this.sortOptions] as SortOptions[], null, this.pagination);
-  }
-
-  clearPagination(): QueryOptions {
-    return new QueryOptions([...this.whereClauses] as WhereClause[], [...this.sortOptions] as SortOptions[], this.dateRange, null);
-  }
-
-  clone(modifications: {
-    where?: WhereClause[];
-    sort?: SortOptions[];
-    dateRange?: DateRangeOptions | null;
-    pagination?: PaginationOptions | null;
-  }): QueryOptions {
-    return Factory.clone(this, modifications);
-  }
-}
-
-// Factory function
-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/QueryOptionsFactory.ts

@@ -1,95 +0,0 @@
-/**
- * Query Options Factory
- * Single Responsibility: Create query options
- *
- * Max lines: 150 (enforced for maintainability)
- */
-
-import type { WhereFilterOp, OrderByDirection } from 'firebase/firestore';
-import type { SortOptions, DateRangeOptions, PaginationOptions } from './QueryOptions';
-import { WhereClause } from './WhereClause';
-import { QueryOptions } from './QueryOptions';
-
-/**
- * Create empty query options
- */
-export function empty(): QueryOptions {
-  return QueryOptions.empty();
-}
-
-/**
- * Create query options from partial configuration
- */
-export function create(options: {
-  where?: WhereClause[];
-  sort?: SortOptions[];
-  dateRange?: DateRangeOptions;
-  pagination?: PaginationOptions;
-}): QueryOptions {
-  return QueryOptions.create(options);
-}
-
-/**
- * Create query options with where clause
- */
-export function withWhere(
-  baseOptions: QueryOptions,
-  field: string,
-  operator: WhereFilterOp,
-  value: unknown
-): QueryOptions {
-  const clause = new WhereClause(field, operator, value);
-  return baseOptions.withWhere(clause);
-}
-
-/**
- * Create query options with sort
- */
-export function withSort(
-  baseOptions: QueryOptions,
-  field: string,
-  direction: OrderByDirection
-): QueryOptions {
-  return baseOptions.withSort({ field, direction });
-}
-
-/**
- * Create query options with date range
- */
-export function withDateRange(
-  baseOptions: QueryOptions,
-  field: string,
-  startDate?: Date,
-  endDate?: Date
-): QueryOptions {
-  return baseOptions.withDateRange({ field, startDate, endDate });
-}
-
-/**
- * Create query options with pagination
- */
-export function withPagination(
-  baseOptions: QueryOptions,
-  pagination: PaginationOptions
-): QueryOptions {
-  return baseOptions.withPagination(pagination);
-}
-
-/**
- * Create query options with limit
- */
-export function withLimit(baseOptions: QueryOptions, limit: number): QueryOptions {
-  return baseOptions.withLimit(limit);
-}
-
-/**
- * Clone query options with modifications
- */
-export function clone(baseOptions: QueryOptions, modifications: {
-  where?: WhereClause[];
-  sort?: SortOptions[];
-  dateRange?: DateRangeOptions | null;
-  pagination?: PaginationOptions | null;
-}): QueryOptions {
-  return baseOptions.clone(modifications);
-}

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

@@ -1,110 +0,0 @@
-/**
- * Query Options Helpers
- * Single Responsibility: Provide helper functions for query options
- *
- * Max lines: 150 (enforced for maintainability)
- */
-
-import type { QueryOptions } from './QueryOptions';
-import type { SortOptions } from './QueryOptions';
-
-/**
- * Check if query options has where clauses
- */
-export function hasWhereClauses(options: QueryOptions): boolean {
-  return options.whereClauses.length > 0;
-}
-
-/**
- * Check if query options has sort options
- */
-export function hasSortOptions(options: QueryOptions): boolean {
-  return options.sortOptions.length > 0;
-}
-
-/**
- * Check if query options has date range
- */
-export function hasDateRange(options: QueryOptions): boolean {
-  return options.dateRange !== null;
-}
-
-/**
- * Check if query options has pagination
- */
-export function hasPagination(options: QueryOptions): boolean {
-  return options.pagination !== null;
-}
-
-/**
- * Check if query options is empty
- */
-export function isEmpty(options: QueryOptions): boolean {
-  return (
-    options.whereClauses.length === 0 &&
-    options.sortOptions.length === 0 &&
-    options.dateRange === null &&
-    options.pagination === null
-  );
-}
-
-/**
- * Get where clause count
- */
-export function getWhereClauseCount(options: QueryOptions): number {
-  return options.whereClauses.length;
-}
-
-/**
- * Get sort option count
- */
-export function getSortOptionCount(options: QueryOptions): number {
-  return options.sortOptions.length;
-}
-
-/**
- * Get first sort option
- */
-export function getFirstSortOption(options: QueryOptions): SortOptions | null {
-  return options.sortOptions.length > 0 ? options.sortOptions[0] || null : null;
-}
-
-/**
- * Check if query has limit
- */
-export function hasLimit(options: QueryOptions): boolean {
-  return options.pagination !== null && options.pagination.limit !== undefined;
-}
-
-/**
- * Get limit value
- */
-export function getLimit(options: QueryOptions): number | null {
-  return options.pagination?.limit || null;
-}
-
-/**
- * Get cursor value
- */
-export function getCursor(options: QueryOptions): number | null {
-  return options.pagination?.cursor || null;
-}
-
-/**
- * Convert query options to summary object
- */
-export function toSummary(options: QueryOptions): {
-  whereCount: number;
-  sortCount: number;
-  hasDateRange: boolean;
-  hasPagination: boolean;
-  limit: number | null;
-} {
-  return {
-    whereCount: options.whereClauses.length,
-    sortCount: options.sortOptions.length,
-    hasDateRange: options.dateRange !== null,
-    hasPagination: options.pagination !== null,
-    limit: options.pagination?.limit || null,
-  };
-}

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

@@ -1,114 +0,0 @@
-/**
- * Where Clause Value Object (Main)
- * 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';
-import * as Validation from './WhereClauseValidation';
-import * as Helpers from './WhereClauseHelpers';
-
-/**
- * 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;
-
-  constructor(field: string, operator: WhereFilterOp, value: unknown) {
-    this.field = field;
-    this.operator = operator;
-    this.value = Object.freeze(value);
-  }
-
-  // Instance methods using helpers
-  validate(): { valid: boolean; errors: string[] } {
-    return Validation.validateWhereClause(this);
-  }
-
-  equals(other: WhereClause): boolean {
-    return Helpers.whereClausesEqual(this, other);
-  }
-
-  isCompatibleWith(other: WhereClause): boolean {
-    return Helpers.areClausesCompatible(this, other);
-  }
-
-  getFieldPath(): string[] {
-    return Helpers.getFieldPath(this);
-  }
-
-  isNestedField(): boolean {
-    return Helpers.isNestedField(this);
-  }
-
-  getTopLevelField(): string {
-    return Helpers.getTopLevelField(this);
-  }
-
-  getDescription(): string {
-    return Helpers.getDescription(this);
-  }
-
-  toObject(): { field: string; operator: WhereFilterOp; value: unknown } {
-    return Helpers.toObject(this);
-  }
-
-  withValue(newValue: unknown): WhereClause {
-    return new WhereClause(this.field, this.operator, newValue);
-  }
-
-  withField(newField: string): WhereClause {
-    return new WhereClause(newField, this.operator, this.value);
-  }
-
-  withOperator(newOperator: WhereFilterOp): WhereClause {
-    return new WhereClause(this.field, newOperator, this.value);
-  }
-
-  isEquality(): boolean {
-    return Helpers.isEqualityClause(this);
-  }
-
-  isInequality(): boolean {
-    return Helpers.isInequalityClause(this);
-  }
-
-  isComparison(): boolean {
-    return Helpers.isComparisonClause(this);
-  }
-
-  isArrayOperator(): boolean {
-    return Helpers.isArrayClause(this);
-  }
-
-  isMembership(): boolean {
-    return Helpers.isMembershipClause(this);
-  }
-
-  requiresArrayValue(): boolean {
-    return Validation.requiresArrayValue(this.operator);
-  }
-}
-

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

@@ -1,101 +0,0 @@
-/**
- * Where Clause Factory
- * Single Responsibility: Create where clauses
- *
- * Max lines: 150 (enforced for maintainability)
- */
-
-import type { WhereFilterOp } from 'firebase/firestore';
-import { WhereClause } from './WhereClause';
-
-/**
- * Create equals where clause
- */
-export function equals(field: string, value: unknown): WhereClause {
-  return new WhereClause(field, '==', value);
-}
-
-/**
- * Create not-equals where clause
- */
-export function notEquals(field: string, value: unknown): WhereClause {
-  return new WhereClause(field, '!=', value);
-}
-
-/**
- * Create less-than where clause
- */
-export function lessThan(field: string, value: unknown): WhereClause {
-  return new WhereClause(field, '<', value);
-}
-
-/**
- * Create less-than-or-equal where clause
- */
-export function lessThanOrEqual(field: string, value: unknown): WhereClause {
-  return new WhereClause(field, '<=', value);
-}
-
-/**
- * Create greater-than where clause
- */
-export function greaterThan(field: string, value: unknown): WhereClause {
-  return new WhereClause(field, '>', value);
-}
-
-/**
- * Create greater-than-or-equal where clause
- */
-export function greaterThanOrEqual(field: string, value: unknown): WhereClause {
-  return new WhereClause(field, '>=', value);
-}
-
-/**
- * Create array-contains where clause
- */
-export function arrayContains(field: string, value: unknown): WhereClause {
-  return new WhereClause(field, 'array-contains', value);
-}
-
-/**
- * Create in where clause
- */
-export function inOp(field: string, values: unknown[]): WhereClause {
-  return new WhereClause(field, 'in', values);
-}
-
-/**
- * Create not-in where clause
- */
-export function notIn(field: string, values: unknown[]): WhereClause {
-  return new WhereClause(field, 'not-in', values);
-}
-
-/**
- * Create array-contains-any where clause
- */
-export function arrayContainsAny(field: string, values: unknown[]): WhereClause {
-  return new WhereClause(field, 'array-contains-any', values);
-}
-
-/**
- * Create where clause with custom operator
- */
-export function where(
-  field: string,
-  operator: WhereFilterOp,
-  value: unknown
-): WhereClause {
-  return new WhereClause(field, operator, value);
-}
-
-/**
- * Create where clause from object
- */
-export function fromObject(obj: {
-  field: string;
-  operator: WhereFilterOp;
-  value: unknown;
-}): WhereClause {
-  return new WhereClause(obj.field, obj.operator, obj.value);
-}

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

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