@umituz/react-native-firebase 2.6.2 → 2.6.4

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

@@ -0,0 +1,110 @@
+/**
+ * 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, DateRangeOptions, PaginationOptions } 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

@@ -0,0 +1,115 @@
+/**
+ * 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';
+import * as Factory from './WhereClauseFactory';
+
+/**
+ * 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

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

@@ -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/presentation/hooks/useFirestoreMutation.ts

@@ -1,7 +1,7 @@
 /**
  * useFirestoreMutation
  *
- * TanStack Mutation wrapper for Firestore write operations.
+ * TanStack Mutation integration for Firestore write operations.
  * Automatically invalidates specified query keys on success.
  *
  * @example

package/src/domains/firestore/presentation/hooks/useFirestoreQuery.ts

@@ -1,7 +1,7 @@
 /**
  * useFirestoreQuery
  *
- * TanStack Query wrapper optimized for Firestore data fetching.
+ * TanStack Query integration for Firestore data fetching.
  * Provides Firestore-aware defaults, retry logic, and error handling.
  *
  * @example

package/src/shared/infrastructure/config/base/ServiceClientSingleton.ts

@@ -0,0 +1,29 @@
+/**
+ * Service Client Singleton Base
+ * Base singleton pattern for service clients
+ *
+ * Max lines: 150 (enforced for maintainability)
+ */
+
+export abstract class ServiceClientSingleton<TInstance> {
+  protected instance: TInstance | null = null;
+
+  protected constructor() {}
+
+  abstract initialize(): Promise<TInstance>;
+
+  getInstance(): TInstance {
+    if (!this.instance) {
+      throw new Error('Service not initialized. Call initialize() first.');
+    }
+    return this.instance;
+  }
+
+  isInitialized(): boolean {
+    return this.instance !== null;
+  }
+
+  reset(): void {
+    this.instance = null;
+  }
+}