@umituz/react-native-firebase 2.6.0 → 2.6.2

package/src/domains/firestore/domain/entities/Document_part_ab

@@ -0,0 +1,83 @@
+  withData<K extends keyof T>(field: K, value: T[K]): Document<T> {
+    if (!this.data) {
+      throw new Error('Cannot update null document data');
+    }
+
+    const newData = { ...this.data, [field]: value };
+    return new Document(
+      {
+        id: this.id,
+        exists: true,
+        data() {
+          return newData;
+        },
+      } as unknown as DocumentSnapshot<T>,
+      this.path
+    );
+  }
+
+  /**
+   * Validate document data against required fields
+   */
+  validateRequiredFields(requiredFields: (keyof T)[]): { valid: boolean; missing: (keyof T)[] } {
+    if (!this.data) {
+      return { valid: false, missing: requiredFields };
+    }
+
+    const missing = requiredFields.filter(field => !this.hasField(field));
+    return {
+      valid: missing.length === 0,
+      missing,
+    };
+  }
+
+  /**
+   * Check if document matches filter criteria
+   */
+  matches(filter: Partial<T>): boolean {
+    if (!this.data) return false;
+
+    return Object.entries(filter).every(([key, value]) => {
+      const fieldValue = this.data![key as keyof T];
+      return fieldValue === value;
+    });
+  }
+
+  /**
+   * Check if document matches filter criteria
+   */
+  matches(filter: Partial<T>): boolean {
+    if (!this.data) return false;
+
+    return Object.entries(filter).every(([key, value]) => {
+      return this.data[key as keyof T] === value;
+    });
+  }
+
+  /**
+   * Get document size in bytes (approximate)
+   * Useful for quota management
+   */
+  getSize(): number {
+    if (!this.data) return 0;
+
+    return JSON.stringify(this.data).length;
+  }
+
+  /**
+   * Check if document size exceeds limit
+   */
+  exceedsSizeLimit(maxBytes: number): boolean {
+    return this.getSize() > maxBytes;
+  }
+}
+
+/**
+ * Factory function to create document entity
+ */
+export function createDocument<T extends DocumentData>(
+  snapshot: DocumentSnapshot<T>,
+  path: string
+): Document<T> {
+  return Document.fromSnapshot(snapshot, path);
+}

package/src/domains/firestore/domain/index.ts

@@ -0,0 +1,65 @@
+/**
+ * Firestore Domain Layer
+ * Domain-Driven Design (DDD) - Domain Exports
+ *
+ * Pure domain logic without infrastructure concerns.
+ * Exports entities, value objects, and domain services.
+ */
+
+// Domain Errors
+export {
+  FirebaseFirestoreError,
+  FirebaseFirestoreInitializationError,
+  FirebaseFirestoreQuotaError,
+} from './errors/FirebaseFirestoreError';
+
+// Domain Entities
+export { Collection, createCollection, fromReference, fromQuery } from './entities/Collection';
+export type { CollectionMetadata } from './entities/Collection';
+
+// Document entity (if exists)
+// export { Document, createDocument } from './entities/Document';
+// export type { DocumentMetadata } from './entities/Document';
+
+// Collection Entity Helpers
+export {
+  isParentOf,
+  getCollectionId,
+  collectionsEqual,
+  getCollectionInfo,
+  collectionFromPath,
+  getSubCollectionNames,
+  buildCollectionPath,
+  parseCollectionPath,
+} from './entities/CollectionHelpers';
+
+// Collection Utilities
+export {
+  getCollectionDepth,
+  collectionToObject,
+  isQueryReference,
+} from './entities/CollectionUtils';
+
+// Collection Validation
+export {
+  isValidCollectionName,
+  isValidCollectionPath,
+  isValidCollection,
+  extractCollectionNameFromPath,
+  extractParentCollectionPath,
+  isDocumentPath,
+  isCollectionPath,
+  isUserCollectionPath,
+  extractUserIdFromPath,
+  createSubCollectionPath,
+} from './entities/CollectionValidation';
+
+// Domain Value Objects
+// export { QueryOptions, createQueryOptions } from './value-objects/QueryOptions';
+// export { WhereClause, createWhereClause, where } from './value-objects/WhereClause';
+// export type { SortOptions, DateRangeOptions, PaginationOptions } from './value-objects/QueryOptions';
+// export type { WhereOperator } from './value-objects/WhereClause';
+
+// Domain Services
+// export { QueryService, createQueryService } from './services/QueryService';
+// export type { QueryBuilderResult } from './services/QueryService';

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

@@ -0,0 +1,182 @@
+/**
+ * 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;
+  }
+
+  /**
+   * 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/services/QueryServiceAnalysis.ts.bak

@@ -0,0 +1,169 @@
+/**
+ * Query Service Analysis
+ * Single Responsibility: Analyze query complexity and metadata
+ *
+ * Provides analysis functionality for query options.
+ * Extracts field information and calculates complexity scores.
+ *
+ * Max lines: 150 (enforced for maintainability)
+ */
+
+import { QueryOptions } from '../value-objects/QueryOptions';
+
+/**
+ * Extract field names from query options
+ */
+export function extractFields(options: QueryOptions): string[] {
+  const fields = new Set<string>();
+
+  for (const clause of options.whereClauses) {
+    fields.add(clause.field);
+  }
+
+  for (const sort of options.sortOptions) {
+    fields.add(sort.field);
+  }
+
+  if (options.dateRange) {
+    fields.add(options.dateRange.field);
+  }
+
+  return Array.from(fields);
+}
+
+/**
+ * Check if query uses array operators
+ */
+export function hasArrayOperators(options: QueryOptions): boolean {
+  return options.whereClauses.some(clause => clause.isArrayOperator());
+}
+
+/**
+ * Check if query uses membership operators
+ */
+export function hasMembershipOperators(options: QueryOptions): boolean {
+  return options.whereClauses.some(clause => clause.isMembership());
+}
+
+/**
+ * Get query complexity score
+ * Higher score = more complex query
+ */
+export function getComplexityScore(options: QueryOptions): number {
+  let score = 0;
+
+  score += options.whereClauses.length * 1;
+  score += options.sortOptions.length * 2;
+  score += options.dateRange ? 3 : 0;
+  score += options.pagination?.limit ? 1 : 0;
+
+  // Array and membership operators add complexity
+  if (hasArrayOperators(options)) score += 5;
+  if (hasMembershipOperators(options)) score += 5;
+
+  return score;
+}
+
+/**
+ * Check if query is too complex
+ */
+export function isTooComplex(options: QueryOptions, maxScore: number = 20): boolean {
+  return getComplexityScore(options) > maxScore;
+}
+
+/**
+ * Get query statistics
+ */
+export function getQueryStats(options: QueryOptions): {
+  readonly whereClauseCount: number;
+  readonly sortOptionCount: number;
+  readonly hasDateRange: boolean;
+  readonly hasPagination: boolean;
+  readonly complexityScore: number;
+  readonly fieldCount: number;
+} {
+  return {
+    whereClauseCount: options.whereClauses.length,
+    sortOptionCount: options.sortOptions.length,
+    hasDateRange: options.hasDateRange(),
+    hasPagination: options.hasPagination(),
+    complexityScore: getComplexityScore(options),
+    fieldCount: extractFields(options).length,
+  };
+}
+
+/**
+ * Check if query is simple (low complexity)
+ */
+export function isSimpleQuery(options: QueryOptions, maxScore: number = 5): boolean {
+  return getComplexityScore(options) <= maxScore;
+}
+
+/**
+ * Check if query is moderate complexity
+ */
+export function isModerateQuery(options: QueryOptions): boolean {
+  const score = getComplexityScore(options);
+  return score > 5 && score <= 15;
+}
+
+/**
+ * Check if query is high complexity
+ */
+export function isComplexQuery(options: QueryOptions): boolean {
+  return getComplexityScore(options) > 15;
+}
+
+/**
+ * Get query complexity level
+ */
+export function getComplexityLevel(options: QueryOptions): 'simple' | 'moderate' | 'complex' {
+  if (isSimpleQuery(options)) {
+    return 'simple';
+  }
+
+  if (isModerateQuery(options)) {
+    return 'moderate';
+  }
+
+  return 'complex';
+}
+
+/**
+ * Compare two queries by complexity
+ */
+export function compareComplexity(options1: QueryOptions, options2: QueryOptions): number {
+  const score1 = getComplexityScore(options1);
+  const score2 = getComplexityScore(options2);
+
+  return score1 - score2;
+}
+
+/**
+ * Get query performance hints
+ */
+export function getPerformanceHints(options: QueryOptions): string[] {
+  const hints: string[] = [];
+
+  if (hasArrayOperators(options)) {
+    hints.push('Array operators can impact performance');
+  }
+
+  if (hasMembershipOperators(options)) {
+    hints.push('Membership operators (in, not-in) are limited to 10 values');
+  }
+
+  if (options.whereClauses.length > 5) {
+    hints.push('Consider reducing number of where clauses');
+  }
+
+  if (!options.pagination?.limit && options.sortOptions.length > 0) {
+    hints.push('Add limit to prevent full collection scans');
+  }
+
+  if (options.dateRange && !options.sortOptions.some(s => s.field === options.dateRange?.field)) {
+    hints.push('Add sort on date range field for better performance');
+  }
+
+  return hints;
+}

package/src/domains/firestore/domain/services/QueryServiceAnalysis_part_aa

@@ -0,0 +1,150 @@
+/**
+ * Query Service Analysis
+ * Single Responsibility: Analyze query complexity and metadata
+ *
+ * Provides analysis functionality for query options.
+ * Extracts field information and calculates complexity scores.
+ *
+ * Max lines: 150 (enforced for maintainability)
+ */
+
+import { QueryOptions } from '../value-objects/QueryOptions';
+
+/**
+ * Extract field names from query options
+ */
+export function extractFields(options: QueryOptions): string[] {
+  const fields = new Set<string>();
+
+  for (const clause of options.whereClauses) {
+    fields.add(clause.field);
+  }
+
+  for (const sort of options.sortOptions) {
+    fields.add(sort.field);
+  }
+
+  if (options.dateRange) {
+    fields.add(options.dateRange.field);
+  }
+
+  return Array.from(fields);
+}
+
+/**
+ * Check if query uses array operators
+ */
+export function hasArrayOperators(options: QueryOptions): boolean {
+  return options.whereClauses.some(clause => clause.isArrayOperator());
+}
+
+/**
+ * Check if query uses membership operators
+ */
+export function hasMembershipOperators(options: QueryOptions): boolean {
+  return options.whereClauses.some(clause => clause.isMembership());
+}
+
+/**
+ * Get query complexity score
+ * Higher score = more complex query
+ */
+export function getComplexityScore(options: QueryOptions): number {
+  let score = 0;
+
+  score += options.whereClauses.length * 1;
+  score += options.sortOptions.length * 2;
+  score += options.dateRange ? 3 : 0;
+  score += options.pagination?.limit ? 1 : 0;
+
+  // Array and membership operators add complexity
+  if (hasArrayOperators(options)) score += 5;
+  if (hasMembershipOperators(options)) score += 5;
+
+  return score;
+}
+
+/**
+ * Check if query is too complex
+ */
+export function isTooComplex(options: QueryOptions, maxScore: number = 20): boolean {
+  return getComplexityScore(options) > maxScore;
+}
+
+/**
+ * Get query statistics
+ */
+export function getQueryStats(options: QueryOptions): {
+  readonly whereClauseCount: number;
+  readonly sortOptionCount: number;
+  readonly hasDateRange: boolean;
+  readonly hasPagination: boolean;
+  readonly complexityScore: number;
+  readonly fieldCount: number;
+} {
+  return {
+    whereClauseCount: options.whereClauses.length,
+    sortOptionCount: options.sortOptions.length,
+    hasDateRange: options.hasDateRange(),
+    hasPagination: options.hasPagination(),
+    complexityScore: getComplexityScore(options),
+    fieldCount: extractFields(options).length,
+  };
+}
+
+/**
+ * Check if query is simple (low complexity)
+ */
+export function isSimpleQuery(options: QueryOptions, maxScore: number = 5): boolean {
+  return getComplexityScore(options) <= maxScore;
+}
+
+/**
+ * Check if query is moderate complexity
+ */
+export function isModerateQuery(options: QueryOptions): boolean {
+  const score = getComplexityScore(options);
+  return score > 5 && score <= 15;
+}
+
+/**
+ * Check if query is high complexity
+ */
+export function isComplexQuery(options: QueryOptions): boolean {
+  return getComplexityScore(options) > 15;
+}
+
+/**
+ * Get query complexity level
+ */
+export function getComplexityLevel(options: QueryOptions): 'simple' | 'moderate' | 'complex' {
+  if (isSimpleQuery(options)) {
+    return 'simple';
+  }
+
+  if (isModerateQuery(options)) {
+    return 'moderate';
+  }
+
+  return 'complex';
+}
+
+/**
+ * Compare two queries by complexity
+ */
+export function compareComplexity(options1: QueryOptions, options2: QueryOptions): number {
+  const score1 = getComplexityScore(options1);
+  const score2 = getComplexityScore(options2);
+
+  return score1 - score2;
+}
+
+/**
+ * Get query performance hints
+ */
+export function getPerformanceHints(options: QueryOptions): string[] {
+  const hints: string[] = [];
+
+  if (hasArrayOperators(options)) {
+    hints.push('Array operators can impact performance');
+  }

package/src/domains/firestore/domain/services/QueryServiceAnalysis_part_ab

@@ -0,0 +1,19 @@
+
+  if (hasMembershipOperators(options)) {
+    hints.push('Membership operators (in, not-in) are limited to 10 values');
+  }
+
+  if (options.whereClauses.length > 5) {
+    hints.push('Consider reducing number of where clauses');
+  }
+
+  if (!options.pagination?.limit && options.sortOptions.length > 0) {
+    hints.push('Add limit to prevent full collection scans');
+  }
+
+  if (options.dateRange && !options.sortOptions.some(s => s.field === options.dateRange?.field)) {
+    hints.push('Add sort on date range field for better performance');
+  }
+
+  return hints;
+}