@umituz/react-native-firebase 2.6.1 → 2.6.3

package/src/domains/firestore/domain/entities/Document_part_aa

@@ -0,0 +1,150 @@
+/**
+ * Document Entity
+ * Single Responsibility: Represent a Firestore document with metadata
+ *
+ * Domain entity that encapsulates document data and metadata.
+ * Provides business logic for document operations.
+ *
+ * Max lines: 150 (enforced for maintainability)
+ */
+
+import type { DocumentData, DocumentSnapshot, Timestamp } from 'firebase/firestore';
+
+/**
+ * Document metadata
+ */
+export interface DocumentMetadata {
+  readonly id: string;
+  readonly createdAt: Timestamp | null;
+  readonly updatedAt: Timestamp | null;
+  readonly exists: boolean;
+}
+
+/**
+ * Document entity
+ * Represents a Firestore document with data and metadata
+ */
+export class Document<T extends DocumentData = DocumentData> {
+  readonly id: string;
+  readonly data: T | null;
+  readonly metadata: DocumentMetadata;
+  readonly path: string;
+
+  constructor(snapshot: DocumentSnapshot<T>, path: string) {
+    this.id = snapshot.id;
+    this.data = snapshot.data() || null;
+    this.path = path;
+    this.metadata = {
+      id: snapshot.id,
+      createdAt: this.extractTimestamp(snapshot, 'createdAt'),
+      updatedAt: this.extractTimestamp(snapshot, 'updatedAt'),
+      exists: snapshot.exists(),
+    };
+  }
+
+  /**
+   * Create document from snapshot with custom path
+   */
+  static fromSnapshot<T extends DocumentData>(
+    snapshot: DocumentSnapshot<T>,
+    path: string
+  ): Document<T> {
+    return new Document(snapshot, path);
+  }
+
+  /**
+   * Check if document exists
+   */
+  exists(): boolean {
+    return this.metadata.exists && this.data !== null;
+  }
+
+  /**
+   * Get field value from document data
+   */
+  getField<K extends keyof T>(field: K): T[K] | null {
+    return this.data?.[field] ?? null;
+  }
+
+  /**
+   * Check if document has a specific field
+   */
+  hasField<K extends keyof T>(field: K): boolean {
+    return this.data !== null && field in this.data;
+  }
+
+  /**
+   * Get document age in milliseconds
+   * Returns null if createdAt is not set
+   */
+  getAge(): number | null {
+    if (!this.metadata.createdAt) return null;
+    return Date.now() - this.metadata.createdAt.toMillis();
+  }
+
+  /**
+   * Check if document is recent (created within specified milliseconds)
+   */
+  isRecent(maxAgeMs: number): boolean {
+    const age = this.getAge();
+    return age !== null && age <= maxAgeMs;
+  }
+
+  /**
+   * Check if document was updated after creation (modified)
+   */
+  isModified(): boolean {
+    if (!this.metadata.createdAt || !this.metadata.updatedAt) return false;
+    return this.metadata.updatedAt.toMillis() > this.metadata.createdAt.toMillis();
+  }
+
+  /**
+   * Get time since last update in milliseconds
+   * Returns null if updatedAt is not set
+   */
+  getTimeSinceUpdate(): number | null {
+    if (!this.metadata.updatedAt) return null;
+    return Date.now() - this.metadata.updatedAt.toMillis();
+  }
+
+  /**
+   * Check if document is stale (not updated within specified milliseconds)
+   */
+  isStale(maxStaleMs: number): boolean {
+    const timeSinceUpdate = this.getTimeSinceUpdate();
+    return timeSinceUpdate !== null && timeSinceUpdate > maxStaleMs;
+  }
+
+  /**
+   * Convert to plain object (for serialization)
+   */
+  toObject(): { id: string; data: T | null; metadata: DocumentMetadata } {
+    return {
+      id: this.id,
+      data: this.data,
+      metadata: this.metadata,
+    };
+  }
+
+  /**
+   * Extract timestamp field from document snapshot
+   */
+  private extractTimestamp(
+    snapshot: DocumentSnapshot<T>,
+    field: string
+  ): Timestamp | null {
+    const data = snapshot.data();
+    if (!data) return null;
+
+    const value = data[field as keyof T];
+    if (value && typeof value === 'object' && 'toDate' in value && typeof value.toDate === 'function') {
+      return value as unknown as Timestamp;
+    }
+
+    return null;
+  }
+
+  /**
+   * Create a new document with updated data
+   * Useful for immutability patterns
+   */

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

@@ -14,17 +14,44 @@ export {
 } from './errors/FirebaseFirestoreError';
 
 // Domain Entities
-export { Document, createDocument } from './entities/Document';
-export { Collection, createCollection } from './entities/Collection';
-export type { DocumentMetadata } from './entities/Document';
+export { Collection, createCollection, fromReference, fromQuery } from './entities/Collection';
 export type { CollectionMetadata } from './entities/Collection';
 
+// 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 { WhereClause, equals, where, create as createWhereClause } 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/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;
+}

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 @@
+}