@umituz/react-native-firebase 2.5.1 → 2.6.1

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

@@ -0,0 +1,320 @@
+/**
+ * Query Options Value Object
+ * 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[] 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);
+  }
+
+  /**
+   * 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
+   */
+  clone(modifications: {
+    where?: WhereClause[];
+    sort?: SortOptions[];
+    dateRange?: DateRangeOptions | null;
+    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,
+    });
+  }
+}
+
+/**
+ * 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

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

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

@@ -0,0 +1,182 @@
+/**
+ * Query Options Validation
+ * Single Responsibility: Validate and check query options
+ *
+ * Validation and type checking functionality for QueryOptions.
+ * Separated for better maintainability.
+ *
+ * Max lines: 150 (enforced for maintainability)
+ */
+
+import { QueryOptions } from './QueryOptions';
+
+/**
+ * Validate query options
+ */
+export function validateOptions(options: QueryOptions): { valid: boolean; errors: string[] } {
+  const errors: string[] = [];
+
+  // Validate where clauses
+  for (const clause of options.whereClauses) {
+    const clauseValidation = clause.validate();
+    if (!clauseValidation.valid) {
+      errors.push(...clauseValidation.errors);
+    }
+  }
+
+  // Validate sort options
+  for (const sort of options.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 (options.dateRange) {
+    if (!options.dateRange.field || typeof options.dateRange.field !== 'string') {
+      errors.push('Date range field must be a non-empty string');
+    }
+    if (options.dateRange.startDate && !(options.dateRange.startDate instanceof Date)) {
+      errors.push('Start date must be a Date instance');
+    }
+    if (options.dateRange.endDate && !(options.dateRange.endDate instanceof Date)) {
+      errors.push('End date must be a Date instance');
+    }
+    if (
+      options.dateRange.startDate &&
+      options.dateRange.endDate &&
+      options.dateRange.startDate > options.dateRange.endDate
+    ) {
+      errors.push('Start date must be before end date');
+    }
+  }
+
+  // Validate pagination
+  if (options.pagination) {
+    if (options.pagination.limit !== undefined && (typeof options.pagination.limit !== 'number' || options.pagination.limit <= 0)) {
+      errors.push('Pagination limit must be a positive number');
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+  };
+}
+
+/**
+ * Check if has any where clauses
+ */
+export function hasWhereClauses(options: QueryOptions): boolean {
+  return options.whereClauses.length > 0;
+}
+
+/**
+ * Check if has any sort options
+ */
+export function hasSort(options: QueryOptions): boolean {
+  return options.sortOptions.length > 0;
+}
+
+/**
+ * Check if has date range
+ */
+export function hasDateRange(options: QueryOptions): boolean {
+  return options.dateRange !== null;
+}
+
+/**
+ * Check if has pagination
+ */
+export function hasPagination(options: QueryOptions): boolean {
+  return options.pagination !== null;
+}
+
+/**
+ * Check if is empty (no options set)
+ */
+export function isEmpty(options: QueryOptions): boolean {
+  return !hasWhereClauses(options) &&
+         !hasSort(options) &&
+         !hasDateRange(options) &&
+         !hasPagination(options);
+}
+
+/**
+ * Check if options have date range filter
+ */
+export function hasDateFilter(options: QueryOptions): boolean {
+  return hasDateRange(options);
+}
+
+/**
+ * Check if options have limit set
+ */
+export function hasLimit(options: QueryOptions): boolean {
+  return options.pagination?.limit !== undefined;
+}
+
+/**
+ * Check if options have cursor set
+ */
+export function hasCursor(options: QueryOptions): boolean {
+  return options.pagination?.cursor !== undefined;
+}
+
+/**
+ * Check if options are valid for compound queries
+ */
+export function isValidForCompoundQuery(options: QueryOptions): boolean {
+  // Check for array/membership operator conflicts
+  const arrayCount = options.whereClauses.filter(c => c.isArrayOperator() || c.isMembership()).length;
+
+  if (arrayCount > 1) {
+    return false;
+  }
+
+  return validateOptions(options).valid;
+}
+
+/**
+ * Check if options are ready for execution
+ */
+export function isReadyToExecute(options: QueryOptions): boolean {
+  if (!validateOptions(options).valid) {
+    return false;
+  }
+
+  // Must have at least one filter
+  if (isEmpty(options)) {
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Get query options type
+ */
+export function getQueryType(options: QueryOptions): 'empty' | 'simple' | 'complex' {
+  if (isEmpty(options)) {
+    return 'empty';
+  }
+
+  const complexity = options.whereClauses.length + options.sortOptions.length;
+
+  if (complexity <= 2) {
+    return 'simple';
+  }
+
+  return 'complex';
+}
+
+/**
+ * Check if query is read-only (no modifications needed)
+ */
+export function isReadOnly(options: QueryOptions): boolean {
+  // Query options are always read-only
+  return true;
+}