@umituz/react-native-firebase 2.6.1 → 2.6.3

package/src/domains/firestore/domain/services/QueryService_part_aa

@@ -0,0 +1,150 @@
+/**
+ * Query Service (Main Builder)
+ * Single Responsibility: Build and validate Firestore queries
+ *
+ * Domain service that encapsulates query building logic.
+ * Moves business logic from infrastructure to domain layer.
+ *
+ * Max lines: 150 (enforced for maintainability)
+ */
+
+import type { Query, Firestore, WhereFilterOp } from 'firebase/firestore';
+import { collection, query, where, orderBy, limit, startAfter, startAt } from 'firebase/firestore';
+import { QueryOptions, createQueryOptions } from '../value-objects/QueryOptions';
+import { WhereClause } from '../value-objects/WhereClause';
+
+/**
+ * Query builder result
+ */
+export interface QueryBuilderResult {
+  readonly query: Query;
+  readonly options: QueryOptions;
+}
+
+/**
+ * Query service
+ * Provides query building and validation functionality
+ */
+export class QueryService {
+  private readonly db: Firestore;
+
+  constructor(db: Firestore) {
+    this.db = db;
+  }
+
+  /**
+   * Build a query from options
+   * Main method for query construction
+   */
+  buildQuery(collectionPath: string, options: QueryOptions): QueryBuilderResult {
+    const validation = options.validate();
+    if (!validation.valid) {
+      throw new Error(`Invalid query options: ${validation.errors.join(', ')}`);
+    }
+
+    const collectionRef = collection(this.db, collectionPath);
+    let q: Query = collectionRef;
+
+    // Apply where clauses
+    for (const clause of options.whereClauses) {
+      q = query(q, where(clause.field, clause.operator, clause.value));
+    }
+
+    // Apply sort options
+    for (const sort of options.sortOptions) {
+      q = query(q, orderBy(sort.field, sort.direction));
+    }
+
+    // Apply date range
+    if (options.dateRange) {
+      const { field, startDate, endDate } = options.dateRange;
+      if (startDate) {
+        q = query(q, where(field, '>=', startDate));
+      }
+      if (endDate) {
+        q = query(q, where(field, '<=', endDate));
+      }
+    }
+
+    // Apply pagination
+    if (options.pagination) {
+      const { cursor, limit: limitValue, startAfter: startAfterValue, startAt: startAtValue } = options.pagination;
+
+      if (startAfterValue !== undefined) {
+        q = query(q, startAfter(startAfterValue));
+      }
+
+      if (startAtValue !== undefined) {
+        q = query(q, startAt(startAtValue));
+      }
+
+      if (limitValue !== undefined) {
+        q = query(q, limit(limitValue));
+      }
+    }
+
+    return { query: q, options };
+  }
+
+  /**
+   * Build simple query with single where clause
+   */
+  buildSimpleQuery(
+    collectionPath: string,
+    field: string,
+    operator: WhereFilterOp,
+    value: unknown
+  ): Query {
+    const options = createQueryOptions({
+      where: [WhereClause.create(field, operator, value)],
+    });
+
+    return this.buildQuery(collectionPath, options).query;
+  }
+
+  /**
+   * Build query with equality filter
+   */
+  buildEqualsQuery(collectionPath: string, field: string, value: unknown): Query {
+    return this.buildSimpleQuery(collectionPath, field, '==', value);
+  }
+
+  /**
+   * Build query with multiple equality filters
+   */
+  buildMultiEqualsQuery(
+    collectionPath: string,
+    filters: Record<string, unknown>
+  ): Query {
+    const whereClauses = Object.entries(filters).map(([field, value]) =>
+      WhereClause.equals(field, value)
+    );
+
+    const options = createQueryOptions({ where: whereClauses });
+    return this.buildQuery(collectionPath, options).query;
+  }
+
+  /**
+   * Build query with sorting
+   */
+  buildSortedQuery(
+    collectionPath: string,
+    sortField: string,
+    direction: 'asc' | 'desc' = 'asc'
+  ): Query {
+    const options = createQueryOptions({
+      sort: [{ field: sortField, direction }],
+    });
+
+    return this.buildQuery(collectionPath, options).query;
+  }
+
+  /**
+   * Build query with limit
+   */
+  buildLimitedQuery(collectionPath: string, limitValue: number): Query {
+    const options = createQueryOptions({
+      pagination: { limit: limitValue },
+    });
+
+    return this.buildQuery(collectionPath, options).query;

package/src/domains/firestore/domain/services/QueryService_part_ab

@@ -0,0 +1,32 @@
+  }
+
+  /**
+   * Build query with date range
+   */
+  buildDateRangeQuery(
+    collectionPath: string,
+    field: string,
+    startDate?: Date,
+    endDate?: Date
+  ): Query {
+    const options = createQueryOptions({
+      dateRange: { field, startDate, endDate },
+    });
+
+    return this.buildQuery(collectionPath, options).query;
+  }
+
+  /**
+   * Validate query options
+   */
+  validateOptions(options: QueryOptions): { valid: boolean; errors: string[] } {
+    return options.validate();
+  }
+
+  /**
+   * Check if query is empty (no filters)
+   */
+  isEmptyQuery(options: QueryOptions): boolean {
+    return options.isEmpty();
+  }
+}

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

@@ -2,35 +2,24 @@
  * 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';
+import * as Factory from './QueryOptionsFactory';
 
-/**
- * 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;
@@ -38,10 +27,6 @@ export interface PaginationOptions {
   readonly startAt?: number;
 }
 
-/**
- * Query options value object
- * Immutable configuration for Firestore queries
- */
 export class QueryOptions {
   readonly whereClauses: readonly WhereClause[];
   readonly sortOptions: readonly SortOptions[];
@@ -60,16 +45,10 @@ export class QueryOptions {
     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[];
@@ -84,103 +63,76 @@ export class QueryOptions {
     );
   }
 
-  /**
-   * Add where clause
-   */
   withWhere(clause: WhereClause): QueryOptions {
     return new QueryOptions(
       [...this.whereClauses, clause] as WhereClause[],
-      this.sortOptions,
+      [...this.sortOptions] as SortOptions[],
       this.dateRange,
       this.pagination
     );
   }
 
-  /**
-   * Add sort option
-   */
   withSort(sort: SortOptions): QueryOptions {
     return new QueryOptions(
-      this.whereClauses,
+      [...this.whereClauses] as WhereClause[],
       [...this.sortOptions, sort] as SortOptions[],
       this.dateRange,
       this.pagination
     );
   }
 
-  /**
-   * Set date range
-   */
   withDateRange(dateRange: DateRangeOptions): QueryOptions {
     return new QueryOptions(
-      this.whereClauses,
-      this.sortOptions,
+      [...this.whereClauses] as WhereClause[],
+      [...this.sortOptions] as SortOptions[],
       dateRange,
       this.pagination
     );
   }
 
-  /**
-   * Set pagination
-   */
   withPagination(pagination: PaginationOptions): QueryOptions {
     return new QueryOptions(
-      this.whereClauses,
-      this.sortOptions,
+      [...this.whereClauses] as WhereClause[],
+      [...this.sortOptions] as SortOptions[],
       this.dateRange,
       pagination
     );
   }
 
-  /**
-   * Remove all where clauses
-   */
+  withLimit(limit: number): QueryOptions {
+    return this.withPagination({
+      ...this.pagination,
+      limit,
+    } as PaginationOptions);
+  }
+
   clearWhere(): QueryOptions {
-    return new QueryOptions([], this.sortOptions, this.dateRange, this.pagination);
+    return new QueryOptions([], [...this.sortOptions] as SortOptions[], this.dateRange, this.pagination);
   }
 
-  /**
-   * Remove all sort options
-   */
   clearSort(): QueryOptions {
-    return new QueryOptions(this.whereClauses, [], this.dateRange, this.pagination);
+    return new QueryOptions([...this.whereClauses] as WhereClause[], [], this.dateRange, this.pagination);
   }
 
-  /**
-   * Remove date range
-   */
   clearDateRange(): QueryOptions {
-    return new QueryOptions(this.whereClauses, this.sortOptions, null, this.pagination);
+    return new QueryOptions([...this.whereClauses] as WhereClause[], [...this.sortOptions] as SortOptions[], null, this.pagination);
   }
 
-  /**
-   * Remove pagination
-   */
   clearPagination(): QueryOptions {
-    return new QueryOptions(this.whereClauses, this.sortOptions, this.dateRange, null);
+    return new QueryOptions([...this.whereClauses] as WhereClause[], [...this.sortOptions] as 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,
-    });
+    return Factory.clone(this, modifications);
   }
 }
 
-/**
- * Factory function to create query options
- */
+// Factory function
 export function createQueryOptions(options?: {
   where?: WhereClause[];
   sort?: SortOptions[];

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

@@ -1,5 +1,5 @@
 /**
- * Query Options Value Object
+ * Query Options Value Object (Main)
  * Single Responsibility: Encapsulate query configuration options
  *
  * Value object that represents query options in a type-safe way.
@@ -89,7 +89,7 @@ export class QueryOptions {
    */
   withWhere(clause: WhereClause): QueryOptions {
     return new QueryOptions(
-      [...this.whereClauses, clause] as WhereClause[] as WhereClause[],
+      [...this.whereClauses, clause] as WhereClause[],
       this.sortOptions,
       this.dateRange,
       this.pagination
@@ -160,135 +160,6 @@ export class QueryOptions {
     return new QueryOptions(this.whereClauses, this.sortOptions, this.dateRange, null);
   }
 
-  /**
-   * Check if has any where clauses
-   */
-  hasWhereClauses(): boolean {
-    return this.whereClauses.length > 0;
-  }
-
-  /**
-   * Check if has any sort options
-   */
-  hasSort(): boolean {
-    return this.sortOptions.length > 0;
-  }
-
-  /**
-   * Check if has date range
-   */
-  hasDateRange(): boolean {
-    return this.dateRange !== null;
-  }
-
-  /**
-   * Check if has pagination
-   */
-  hasPagination(): boolean {
-    return this.pagination !== null;
-  }
-
-  /**
-   * Check if is empty (no options set)
-   */
-  isEmpty(): boolean {
-    return !this.hasWhereClauses() &&
-           !this.hasSort() &&
-           !this.hasDateRange() &&
-           !this.hasPagination();
-  }
-
-  /**
-   * Validate query options
-   */
-  validate(): { valid: boolean; errors: string[] } {
-    const errors: string[] = [];
-
-    // Validate where clauses
-    for (const clause of this.whereClauses) {
-      const clauseValidation = clause.validate();
-      if (!clauseValidation.valid) {
-        errors.push(...clauseValidation.errors);
-      }
-    }
-
-    // Validate sort options
-    for (const sort of this.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 (this.dateRange) {
-      if (!this.dateRange.field || typeof this.dateRange.field !== 'string') {
-        errors.push('Date range field must be a non-empty string');
-      }
-      if (this.dateRange.startDate && !(this.dateRange.startDate instanceof Date)) {
-        errors.push('Start date must be a Date instance');
-      }
-      if (this.dateRange.endDate && !(this.dateRange.endDate instanceof Date)) {
-        errors.push('End date must be a Date instance');
-      }
-      if (
-        this.dateRange.startDate &&
-        this.dateRange.endDate &&
-        this.dateRange.startDate > this.dateRange.endDate
-      ) {
-        errors.push('Start date must be before end date');
-      }
-    }
-
-    // Validate pagination
-    if (this.pagination) {
-      if (this.pagination.limit !== undefined && (typeof this.pagination.limit !== 'number' || this.pagination.limit <= 0)) {
-        errors.push('Pagination limit must be a positive number');
-      }
-    }
-
-    return {
-      valid: errors.length === 0,
-      errors,
-    };
-  }
-
-  /**
-   * Convert to plain object (for serialization)
-   */
-  toObject(): {
-    where: WhereClause[];
-    sort: SortOptions[];
-    dateRange: DateRangeOptions | null;
-    pagination: PaginationOptions | null;
-  } {
-    return {
-      where: [...this.whereClauses] as WhereClause[],
-      sort: [...this.sortOptions] as SortOptions[],
-      dateRange: this.dateRange,
-      pagination: this.pagination,
-    };
-  }
-
-  /**
-   * Create from plain object
-   */
-  static fromObject(obj: {
-    where?: Array<{ field: string; operator: WhereFilterOp; value: unknown }>;
-    sort?: SortOptions[];
-    dateRange?: DateRangeOptions;
-    pagination?: PaginationOptions;
-  }): QueryOptions {
-    return QueryOptions.create({
-      where: obj.where?.map(w => WhereClause.create(w.field, w.operator, w.value)) || [],
-      sort: obj.sort || [],
-      dateRange: obj.dateRange || null,
-      pagination: obj.pagination || null,
-    });
-  }
-
   /**
    * Clone with modifications
    */
@@ -299,10 +170,10 @@ export class QueryOptions {
     pagination?: PaginationOptions | null;
   }): QueryOptions {
     return QueryOptions.create({
-      where: modifications.where ?? this.whereClauses,
-      sort: modifications.sort ?? this.sortOptions,
-      dateRange: modifications.dateRange ?? this.dateRange,
-      pagination: modifications.pagination ?? this.pagination,
+      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,
     });
   }
 }

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

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