@umituz/react-native-firebase 2.6.3 → 2.6.5

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

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

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

@@ -1,191 +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
-   */
-  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/QueryOptionsSerialization.ts.bak

@@ -1,207 +0,0 @@
-/**
- * Query Options Serialization
- * Single Responsibility: Handle serialization and conversion
- *
- * Serialization and conversion utilities for QueryOptions.
- * Separated for better maintainability.
- *
- * Max lines: 150 (enforced for maintainability)
- */
-
-import { QueryOptions, createQueryOptions } from './QueryOptions';
-import { WhereClause } from './WhereClause';
-import type { SortOptions, DateRangeOptions, PaginationOptions } from './QueryOptions';
-
-/**
- * Convert to plain object (for serialization)
- */
-export function toObject(options: QueryOptions): {
-  where: WhereClause[];
-  sort: SortOptions[];
-  dateRange: DateRangeOptions | null;
-  pagination: PaginationOptions | null;
-} {
-  return {
-    where: [...options.whereClauses],
-    sort: [...options.sortOptions],
-    dateRange: options.dateRange,
-    pagination: options.pagination,
-  };
-}
-
-/**
- * Create from plain object
- */
-export function fromObject(obj: {
-  where?: Array<{ field: string; operator: string; value: unknown }>;
-  sort?: SortOptions[];
-  dateRange?: DateRangeOptions;
-  pagination?: PaginationOptions;
-}): QueryOptions {
-  return QueryOptions.create({
-    where: obj.where?.map(w => WhereClause.create(w.field, w.operator as any, w.value)) || [],
-    sort: obj.sort || [],
-    dateRange: obj.dateRange || null,
-    pagination: obj.pagination || null,
-  });
-}
-
-/**
- * Create from filters object (simplified)
- */
-export function fromFilters(filters: Record<string, unknown>): QueryOptions {
-  const whereClauses = Object.entries(filters).map(([field, value]) =>
-    WhereClause.equals(field, value)
-  );
-
-  return QueryOptions.create({ where: whereClauses });
-}
-
-/**
- * Merge multiple query options
- */
-export function mergeOptions(...options: QueryOptions[]): QueryOptions {
-  if (options.length === 0) {
-    return createQueryOptions();
-  }
-
-  if (options.length === 1) {
-    return options[0];
-  }
-
-  const merged = options.reduce((acc, opt) => {
-    return QueryOptions.create({
-      where: [...acc.whereClauses, ...opt.whereClauses] as WhereClause[],
-      sort: opt.sortOptions.length > 0 ? [...opt.sortOptions] as any[] : [...acc.sortOptions] as any[],
-      dateRange: opt.dateRange ?? acc.dateRange,
-      pagination: opt.pagination ?? acc.pagination,
-    });
-  });
-
-  return merged ?? createQueryOptions();
-}
-
-/**
- * Create paginated query options
- */
-export function createPaginatedOptions(limit: number, cursor?: number): QueryOptions {
-  return createQueryOptions({
-    pagination: { limit, cursor },
-  });
-}
-
-/**
- * Create sorted query options
- */
-export function createSortedOptions(
-  field: string,
-  direction: 'asc' | 'desc' = 'asc'
-): QueryOptions {
-  return createQueryOptions({
-    sort: [{ field, direction }],
-  });
-}
-
-/**
- * Create date range query options
- */
-export function createDateRangeOptions(
-  field: string,
-  startDate?: Date,
-  endDate?: Date
-): QueryOptions {
-  return createQueryOptions({
-    dateRange: { field, startDate, endDate },
-  });
-}
-
-/**
- * Clone query options with safety checks
- */
-export function cloneSafe(options: QueryOptions, defaults?: Partial<{
-  where: WhereClause[];
-  sort: SortOptions[];
-  dateRange: DateRangeOptions;
-  pagination: PaginationOptions;
-}>): QueryOptions {
-  return QueryOptions.create({
-    where: options.whereClauses.length > 0 ? [...options.whereClauses] as WhereClause[] : defaults?.where || [],
-    sort: options.sortOptions.length > 0 ? [...options.sortOptions] as SortOptions[] : defaults?.sort || [],
-    dateRange: options.dateRange ?? defaults?.dateRange ?? null,
-    pagination: options.pagination ?? defaults?.pagination ?? null,
-  });
-}
-
-/**
- * Strip pagination from options
- */
-export function withoutPagination(options: QueryOptions): QueryOptions {
-  return QueryOptions.create({
-    where: [...options.whereClauses] as WhereClause[],
-    sort: [...options.sortOptions] as SortOptions[],
-    dateRange: options.dateRange,
-    pagination: null,
-  });
-}
-
-/**
- * Strip sort from options
- */
-export function withoutSort(options: QueryOptions): QueryOptions {
-  return QueryOptions.create({
-    where: [...options.whereClauses] as WhereClause[],
-    sort: [],
-    dateRange: options.dateRange,
-    pagination: options.pagination,
-  });
-}
-
-/**
- * Strip date range from options
- */
-export function withoutDateRange(options: QueryOptions): QueryOptions {
-  return QueryOptions.create({
-    where: [...options.whereClauses] as WhereClause[],
-    sort: [...options.sortOptions] as SortOptions[],
-    dateRange: null,
-    pagination: options.pagination,
-  });
-}
-
-/**
- * Strip where clauses from options
- */
-export function withoutWhere(options: QueryOptions): QueryOptions {
-  return QueryOptions.create({
-    where: [],
-    sort: [...options.sortOptions] as SortOptions[],
-    dateRange: options.dateRange,
-    pagination: options.pagination,
-  });
-}
-
-/**
- * Add limit to existing options
- */
-export function withLimit(options: QueryOptions, limit: number): QueryOptions {
-  const currentPagination = options.pagination || {};
-  return QueryOptions.create({
-    where: [...options.whereClauses] as WhereClause[],
-    sort: [...options.sortOptions] as SortOptions[],
-    dateRange: options.dateRange,
-    pagination: { ...currentPagination, limit },
-  });
-}
-
-/**
- * Add cursor to existing options
- */
-export function withCursor(options: QueryOptions, cursor: number): QueryOptions {
-  const currentPagination = options.pagination || {};
-  return QueryOptions.create({
-    where: [...options.whereClauses] as WhereClause[],
-    sort: [...options.sortOptions] as SortOptions[],
-    dateRange: options.dateRange,
-    pagination: { ...currentPagination, cursor },
-  });
-}