@umituz/react-native-firebase 2.6.0 → 2.6.2

package/src/domains/firestore/domain/services/QueryServiceHelpers.ts.bak

@@ -0,0 +1,151 @@
+/**
+ * Query Service Helpers
+ * Single Responsibility: Provide helper methods for query operations
+ *
+ * Helper methods for query options manipulation and creation.
+ * Separated from main QueryService for better maintainability.
+ *
+ * Max lines: 150 (enforced for maintainability)
+ */
+
+import type { Query } from 'firebase/firestore';
+import { QueryOptions, createQueryOptions } from '../value-objects/QueryOptions';
+import { WhereClause } from '../value-objects/WhereClause';
+import type { Collection } from '../entities/Collection';
+import type { QueryBuilderResult } from './QueryService';
+
+/**
+ * Create query options from filters object
+ */
+export function createOptionsFromFilters(filters: Record<string, unknown>): QueryOptions {
+  const whereClauses = Object.entries(filters).map(([field, value]) =>
+    WhereClause.equals(field, value)
+  );
+
+  return createQueryOptions({ where: whereClauses });
+}
+
+/**
+ * Merge multiple query options
+ * Later options override earlier ones for conflicting settings
+ */
+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 }],
+  });
+}
+
+/**
+ * Optimize query options
+ * Removes redundant clauses and sorts
+ */
+export function optimizeOptions(options: QueryOptions): QueryOptions {
+  // Remove duplicate where clauses
+  const uniqueWheres = options.whereClauses.filter((clause, index, self) =>
+    index === self.findIndex(c => c.equals(clause))
+  );
+
+  // Remove duplicate sorts
+  const uniqueSorts = options.sortOptions.filter((sort, index, self) =>
+    index === self.findIndex(s => s.field === sort.field && s.direction === sort.direction)
+  );
+
+  return QueryOptions.create({
+    where: uniqueWheres,
+    sort: uniqueSorts,
+    dateRange: options.dateRange,
+    pagination: options.pagination,
+  });
+}
+
+/**
+ * Build query from collection entity
+ */
+export function buildQueryFromCollection(
+  collection: Collection,
+  options: QueryOptions,
+  queryService: any
+): QueryBuilderResult {
+  return queryService.buildQuery(collection.getPath(), options);
+}
+
+/**
+ * Get query description for logging
+ */
+export function describeQuery(options: QueryOptions): string {
+  const parts: string[] = [];
+
+  if (options.hasWhereClauses()) {
+    parts.push(`where: ${options.whereClauses.length} clause(s)`);
+  }
+
+  if (options.hasSort()) {
+    parts.push(`sort: ${options.sortOptions.length} field(s)`);
+  }
+
+  if (options.hasDateRange()) {
+    parts.push('date range: yes');
+  }
+
+  if (options.hasPagination()) {
+    parts.push(`limit: ${options.pagination?.limit || 'none'}`);
+  }
+
+  return parts.length > 0 ? parts.join(', ') : 'no filters';
+}
+
+/**
+ * Clone query options with modifications
+ */
+export function cloneOptions(
+  base: QueryOptions,
+  modifications: {
+    where?: WhereClause[];
+    sort?: Array<{ field: string; direction: 'asc' | 'desc' }>;
+    dateRange?: { field: string; startDate?: Date; endDate?: Date };
+    pagination?: { limit?: number; cursor?: number };
+  }
+): QueryOptions {
+  return QueryOptions.create({
+    where: modifications.where ?? [...base.whereClauses] as WhereClause[],
+    sort: modifications.sort ?? [...base.sortOptions] as any[],
+    dateRange: modifications.dateRange ?? base.dateRange ?? undefined,
+    pagination: modifications.pagination ?? base.pagination ?? undefined,
+  });
+}

package/src/domains/firestore/domain/services/QueryServiceHelpers_part_aa

@@ -0,0 +1,150 @@
+/**
+ * Query Service Helpers
+ * Single Responsibility: Provide helper methods for query operations
+ *
+ * Helper methods for query options manipulation and creation.
+ * Separated from main QueryService for better maintainability.
+ *
+ * Max lines: 150 (enforced for maintainability)
+ */
+
+import type { Query } from 'firebase/firestore';
+import { QueryOptions, createQueryOptions } from '../value-objects/QueryOptions';
+import { WhereClause } from '../value-objects/WhereClause';
+import type { Collection } from '../entities/Collection';
+import type { QueryBuilderResult } from './QueryService';
+
+/**
+ * Create query options from filters object
+ */
+export function createOptionsFromFilters(filters: Record<string, unknown>): QueryOptions {
+  const whereClauses = Object.entries(filters).map(([field, value]) =>
+    WhereClause.equals(field, value)
+  );
+
+  return createQueryOptions({ where: whereClauses });
+}
+
+/**
+ * Merge multiple query options
+ * Later options override earlier ones for conflicting settings
+ */
+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 }],
+  });
+}
+
+/**
+ * Optimize query options
+ * Removes redundant clauses and sorts
+ */
+export function optimizeOptions(options: QueryOptions): QueryOptions {
+  // Remove duplicate where clauses
+  const uniqueWheres = options.whereClauses.filter((clause, index, self) =>
+    index === self.findIndex(c => c.equals(clause))
+  );
+
+  // Remove duplicate sorts
+  const uniqueSorts = options.sortOptions.filter((sort, index, self) =>
+    index === self.findIndex(s => s.field === sort.field && s.direction === sort.direction)
+  );
+
+  return QueryOptions.create({
+    where: uniqueWheres,
+    sort: uniqueSorts,
+    dateRange: options.dateRange,
+    pagination: options.pagination,
+  });
+}
+
+/**
+ * Build query from collection entity
+ */
+export function buildQueryFromCollection(
+  collection: Collection,
+  options: QueryOptions,
+  queryService: any
+): QueryBuilderResult {
+  return queryService.buildQuery(collection.getPath(), options);
+}
+
+/**
+ * Get query description for logging
+ */
+export function describeQuery(options: QueryOptions): string {
+  const parts: string[] = [];
+
+  if (options.hasWhereClauses()) {
+    parts.push(`where: ${options.whereClauses.length} clause(s)`);
+  }
+
+  if (options.hasSort()) {
+    parts.push(`sort: ${options.sortOptions.length} field(s)`);
+  }
+
+  if (options.hasDateRange()) {
+    parts.push('date range: yes');
+  }
+
+  if (options.hasPagination()) {
+    parts.push(`limit: ${options.pagination?.limit || 'none'}`);
+  }
+
+  return parts.length > 0 ? parts.join(', ') : 'no filters';
+}
+
+/**
+ * Clone query options with modifications
+ */
+export function cloneOptions(
+  base: QueryOptions,
+  modifications: {
+    where?: WhereClause[];
+    sort?: Array<{ field: string; direction: 'asc' | 'desc' }>;
+    dateRange?: { field: string; startDate?: Date; endDate?: Date };
+    pagination?: { limit?: number; cursor?: number };
+  }
+): QueryOptions {
+  return QueryOptions.create({
+    where: modifications.where ?? [...base.whereClauses] as WhereClause[],
+    sort: modifications.sort ?? [...base.sortOptions] as any[],
+    dateRange: modifications.dateRange ?? base.dateRange ?? undefined,
+    pagination: modifications.pagination ?? base.pagination ?? undefined,
+  });

package/src/domains/firestore/domain/services/QueryServiceHelpers_part_ab

@@ -0,0 +1 @@
+}

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.bak

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