@umituz/react-native-firebase 2.6.3 → 2.6.5

package/src/domains/firestore/domain/entities/Document.ts.bak

@@ -1,233 +0,0 @@
-/**
- * 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
-   */
-  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/entities/Document_part_aa

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

@@ -1,83 +0,0 @@
-  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/services/QueryService.ts.bak

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