@umituz/react-native-firebase 2.6.0 → 2.6.2

package/src/domains/firestore/domain/entities/Collection_part_aa

@@ -0,0 +1,150 @@
+/**
+ * Collection Entity
+ * Single Responsibility: Represent a Firestore collection with metadata
+ *
+ * Domain entity that encapsulates collection information and metadata.
+ * Provides business logic for collection operations.
+ *
+ * Max lines: 150 (enforced for maintainability)
+ */
+
+import type { CollectionReference, Query } from 'firebase/firestore';
+import type { Document } from './Document';
+
+/**
+ * Collection metadata
+ */
+export interface CollectionMetadata {
+  readonly name: string;
+  readonly path: string;
+  readonly parentPath?: string;
+}
+
+/**
+ * Collection entity
+ * Represents a Firestore collection with metadata
+ */
+export class Collection<TDocument = unknown> {
+  readonly name: string;
+  readonly path: string;
+  readonly parentPath: string | undefined;
+  private readonly reference: CollectionReference<TDocument> | Query<TDocument>;
+
+  constructor(
+    reference: CollectionReference<TDocument> | Query<TDocument>,
+    metadata: CollectionMetadata
+  ) {
+    this.reference = reference;
+    this.name = metadata.name;
+    this.path = metadata.path;
+    this.parentPath = metadata.parentPath || undefined;
+  }
+
+  /**
+   * Create collection from collection reference
+   */
+  static fromReference<TDocument = unknown>(
+    reference: CollectionReference<TDocument>
+  ): Collection<TDocument> {
+    return new Collection(reference, {
+      name: reference.id,
+      path: reference.path,
+      parentPath: reference.parent?.path || null,
+    });
+  }
+
+  /**
+   * Create collection from query
+   */
+  static fromQuery<TDocument = unknown>(query: Query<TDocument>, name: string, path: string): Collection<TDocument> {
+    return new Collection(query, {
+      name,
+      path,
+      parentPath: path.split('/').slice(0, -2).join('/') || null,
+    });
+  }
+
+  /**
+   * Get collection name
+   */
+  getName(): string {
+    return this.name;
+  }
+
+  /**
+   * Get collection path
+   */
+  getPath(): string {
+    return this.path;
+  }
+
+  /**
+   * Get parent path if exists
+   */
+  getParentPath(): string | null {
+    return this.parentPath;
+  }
+
+  /**
+   * Check if collection is nested (has parent)
+   */
+  isNested(): boolean {
+    return this.parentPath !== null;
+  }
+
+  /**
+   * Check if collection is root level (no parent)
+   */
+  isRootLevel(): boolean {
+    return this.parentPath === null;
+  }
+
+  /**
+   * Get collection depth in hierarchy
+   * Root collections have depth 0
+   */
+  getDepth(): number {
+    if (!this.parentPath) return 0;
+    return this.path.split('/').length / 2 - 1;
+  }
+
+  /**
+   * Get the underlying reference
+   */
+  getReference(): CollectionReference<TDocument> | Query<TDocument> {
+    return this.reference;
+  }
+
+  /**
+   * Check if collection is a query (has filters/limits)
+   */
+  isQuery(): boolean {
+    return 'type' in this.reference && this.reference.type === 'query';
+  }
+
+  /**
+   * Check if collection is a collection reference (no filters)
+   */
+  isCollectionReference(): boolean {
+    return !this.isQuery();
+  }
+
+  /**
+   * Validate collection name format
+   * Collection names must match Firestore requirements
+   */
+  static isValidName(name: string): boolean {
+    // Collection names must be non-empty strings
+    if (!name || typeof name !== 'string' || name.trim() === '') {
+      return false;
+    }
+
+    // Cannot contain special characters
+    const invalidChars = /[\/\\.\s]/;
+    if (invalidChars.test(name)) {
+      return false;
+    }
+
+    // Cannot start or end with double underscore
+    if (name.startsWith('__') || name.endsWith('__')) {
+      return false;

package/src/domains/firestore/domain/entities/Collection_part_ab

@@ -0,0 +1,138 @@
+    }
+
+    // Reasonable length limit
+    if (name.length > 100) {
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Validate collection path format
+   * Paths must follow Firestore path structure
+   */
+  static isValidPath(path: string): boolean {
+    if (!path || typeof path !== 'string' || path.trim() === '') {
+      return false;
+    }
+
+    const segments = path.split('/');
+    if (segments.length < 2 || segments.length % 2 !== 0) {
+      return false;
+    }
+
+    return segments.every(segment => this.isValidName(segment));
+  }
+
+  /**
+   * Extract collection name from path
+   */
+  static extractNameFromPath(path: string): string | null {
+    if (!this.isValidPath(path)) {
+      return null;
+    }
+
+    const segments = path.split('/');
+    return segments[segments.length - 1] || null;
+  }
+
+  /**
+   * Extract parent path from collection path
+   */
+  static extractParentPath(path: string): string | null {
+    if (!this.isValidPath(path)) {
+      return null;
+    }
+
+    const segments = path.split('/');
+    if (segments.length <= 2) {
+      return null;
+    }
+
+    return segments.slice(0, -1).join('/');
+  }
+
+  /**
+   * Convert to plain object (for serialization)
+   */
+  toObject(): CollectionMetadata {
+    return {
+      name: this.name,
+      path: this.path,
+      parentPath: this.parentPath || undefined,
+    };
+  }
+
+  /**
+   * Create a sub-collection path
+   */
+  createSubCollectionPath(subCollectionName: string): string | null {
+    if (!Collection.isValidName(subCollectionName)) {
+      return null;
+    }
+
+    return `${this.path}/${subCollectionName}`;
+  }
+
+  /**
+   * Check if collection is a sub-collection of another
+   */
+  isSubCollectionOf(other: Collection): boolean {
+    return this.parentPath === other.path;
+  }
+
+  /**
+   * Check if collection is parent of another
+   */
+  isParentOf(other: Collection): boolean {
+    return other.isSubCollectionOf(this);
+  }
+
+  /**
+   * Get collection ID (similar to name but more explicit)
+   */
+  getId(): string {
+    return this.name;
+  }
+
+  /**
+   * Check if this is a user collection (users/{userId}/{collection})
+   */
+  isUserCollection(): boolean {
+    return this.parentPath?.startsWith('users/') || false;
+  }
+
+  /**
+   * Extract user ID from user collection path
+   * Returns null if not a user collection
+   */
+  extractUserId(): string | null {
+    if (!this.isUserCollection()) return null;
+
+    const segments = this.path.split('/');
+    if (segments.length >= 3 && segments[0] === 'users') {
+      return segments[1];
+    }
+
+    return null;
+  }
+}
+
+/**
+ * Factory function to create collection entity
+ */
+export function createCollection<TDocument = unknown>(
+  reference: CollectionReference<TDocument> | Query<TDocument>,
+  name?: string,
+  path?: string
+): Collection<TDocument> {
+  if ('type' in reference && reference.type === 'query') {
+    if (!name || !path) {
+      throw new Error('name and path are required for query collections');
+    }
+    return Collection.fromQuery(reference, name, path);
+  }
+
+  return Collection.fromReference(reference as CollectionReference<TDocument>);
+}

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

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

@@ -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
+   */