@umituz/react-native-firebase 2.6.1 → 2.6.3

package/src/domains/firestore/domain/entities/CollectionHelpers.ts

@@ -0,0 +1,143 @@
+/**
+ * Collection Entity Helpers
+ * Single Responsibility: Provide utility methods for collections
+ *
+ * Helper methods separated from main Collection entity.
+ *
+ * Max lines: 150 (enforced for maintainability)
+ */
+
+import { Collection } from './Collection';
+import { isValidCollectionPath, isValidCollectionName } from './CollectionValidation';
+
+/**
+ * Check if collection is parent of another
+ */
+export function isParentOf(parent: Collection, child: Collection): boolean {
+  const childPath = child.getPath();
+  const parentPath = parent.getPath();
+  return childPath.startsWith(parentPath + '/');
+}
+
+/**
+ * Get collection ID (similar to name but more explicit)
+ */
+export function getCollectionId(collection: Collection): string {
+  return collection.getName();
+}
+
+/**
+ * Check if collections are equal
+ */
+export function collectionsEqual(col1: Collection, col2: Collection): boolean {
+  return col1.getPath() === col2.getPath();
+}
+
+/**
+ * Get collection size info (metadata)
+ */
+export function getCollectionInfo(collection: Collection): {
+  readonly name: string;
+  readonly path: string;
+  readonly depth: number;
+  readonly isNested: boolean;
+  readonly isRoot: boolean;
+  readonly isUserCollection: boolean;
+} {
+  return {
+    name: collection.getName(),
+    path: collection.getPath(),
+    depth: collection.getDepth(),
+    isNested: collection.isNested(),
+    isRoot: collection.isRootLevel(),
+    isUserCollection: collection.isUserCollection(),
+  };
+}
+
+export function isValidCollection(collection: Collection): boolean {
+  return isValidCollectionName(collection.getName()) &&
+         isValidCollectionPath(collection.getPath());
+}
+
+export function collectionFromPath(db: any, path: string): Collection | null {
+  if (!isValidCollectionPath(path)) {
+    return null;
+  }
+
+  try {
+    const ref = db.collection(path);
+    return Collection.fromReference(ref as any);
+  } catch {
+    return null;
+  }
+}
+
+export function getSubCollectionNames(path: string): string[] {
+  if (!isValidCollectionPath(path)) {
+    return [];
+  }
+
+  const segments = path.split('/');
+  const collections: string[] = [];
+
+  // Extract collection names (even indices)
+  for (let i = 0; i < segments.length; i += 2) {
+    const segment = segments[i];
+    if (segment) {
+      collections.push(segment);
+    }
+  }
+
+  return collections;
+}
+
+export function buildCollectionPath(...parts: string[]): string {
+  if (parts.length === 0 || parts.length % 2 !== 0) {
+    throw new Error('Invalid collection path parts');
+  }
+
+  if (!parts.every(p => isValidCollectionName(p))) {
+    throw new Error('Invalid collection name in parts');
+  }
+
+  return parts.join('/');
+}
+
+export function parseCollectionPath(path: string): {
+  readonly collections: string[];
+  readonly documents: string[];
+  readonly segments: string[];
+} | null {
+  if (!isValidCollectionPath(path)) {
+    return null;
+  }
+
+  const segments = path.split('/');
+  const collections: string[] = [];
+  const documents: string[] = [];
+
+  for (let i = 0; i < segments.length; i += 2) {
+    const collectionSegment = segments[i];
+    if (collectionSegment) {
+      collections.push(collectionSegment);
+    }
+    if (i + 1 < segments.length) {
+      const documentSegment = segments[i + 1];
+      if (documentSegment) {
+        documents.push(documentSegment);
+      }
+    }
+  }
+
+  return { collections, documents, segments };
+}
+
+export function isDocumentPath(path: string): boolean {
+  const segments = path.split('/');
+  return segments.length % 2 === 0 && segments.length >= 2;
+}
+
+export function isCollectionPath(path: string): boolean {
+  const segments = path.split('/');
+  return segments.length % 2 !== 0 && segments.length >= 1;
+}

package/src/domains/firestore/domain/entities/CollectionUtils.ts

@@ -0,0 +1,72 @@
+/**
+ * Collection Utilities
+ * Single Responsibility: Provide utility functions for collection operations
+ *
+ * Max lines: 150 (enforced for maintainability)
+ */
+
+import type { CollectionReference, Query } from 'firebase/firestore';
+import type { Collection, CollectionMetadata } from './Collection';
+
+/**
+ * Get collection depth in hierarchy
+ * Root collections have depth 0
+ */
+export function getCollectionDepth(collection: Collection): number {
+  if (!collection.getParentPath()) return 0;
+  const path = collection.getPath();
+  return path.split('/').length / 2 - 1;
+}
+
+/**
+ * Convert collection to plain object (for serialization)
+ */
+export function collectionToObject(collection: Collection): CollectionMetadata {
+  return {
+    name: collection.getName(),
+    path: collection.getPath(),
+    parentPath: collection.getParentPath(),
+  };
+}
+
+/**
+ * Check if reference is a query (has filters/limits)
+ */
+export function isQueryReference<TDocument>(
+  reference: CollectionReference<TDocument> | Query<TDocument>
+): boolean {
+  return 'type' in reference && reference.type === 'query';
+}
+
+/**
+ * Check if reference is a collection reference (no filters)
+ */
+export function isCollectionReference<TDocument>(
+  reference: CollectionReference<TDocument> | Query<TDocument>
+): boolean {
+  return !isQueryReference(reference);
+}
+
+/**
+ * Get collection size info (metadata)
+ */
+export function getCollectionInfo(collection: Collection): {
+  readonly name: string;
+  readonly path: string;
+  readonly depth: number;
+  readonly isNested: boolean;
+  readonly isRoot: boolean;
+  readonly isUserCollection: boolean;
+  readonly isQuery: boolean;
+} {
+  const reference = collection.getReference();
+  return {
+    name: collection.getName(),
+    path: collection.getPath(),
+    depth: getCollectionDepth(collection),
+    isNested: collection.isNested(),
+    isRoot: collection.isRootLevel(),
+    isUserCollection: collection.isUserCollection(),
+    isQuery: isQueryReference(reference),
+  };
+}

package/src/domains/firestore/domain/entities/CollectionValidation.ts

@@ -0,0 +1,138 @@
+/**
+ * Collection Validation Utilities
+ * Single Responsibility: Validate collection names and paths
+ *
+ * Max lines: 150 (enforced for maintainability)
+ */
+
+import type { Collection } from './Collection';
+
+/**
+ * Validate collection name format
+ */
+export function isValidCollectionName(name: string): boolean {
+  if (!name || typeof name !== 'string' || name.trim() === '') {
+    return false;
+  }
+
+  const invalidChars = /[\/\\.\s]/;
+  if (invalidChars.test(name)) {
+    return false;
+  }
+
+  if (name.startsWith('__') || name.endsWith('__')) {
+    return false;
+  }
+
+  if (name.length > 100) {
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Check if collection is valid
+ */
+export function isValidCollection(collection: Collection): boolean {
+  return isValidCollectionName(collection.getName()) &&
+         isValidCollectionPath(collection.getPath());
+}
+
+/**
+ * Validate collection path format
+ */
+export function isValidCollectionPath(path: string): boolean {
+  if (!path || typeof path !== 'string' || path.trim() === '') {
+    return false;
+  }
+
+  const segments = path.split('/');
+  if (segments.length < 1 || segments.length % 2 === 0) {
+    return false;
+  }
+
+  return segments.every(segment => isValidCollectionName(segment));
+}
+
+/**
+ * Extract collection name from path
+ */
+export function extractCollectionNameFromPath(path: string): string | null {
+  if (!isValidCollectionPath(path)) {
+    return null;
+  }
+
+  const segments = path.split('/');
+  return segments[segments.length - 1] || null;
+}
+
+/**
+ * Extract parent path from collection path
+ */
+export function extractParentCollectionPath(path: string): string | null {
+  if (!isValidCollectionPath(path)) {
+    return null;
+  }
+
+  const segments = path.split('/');
+  if (segments.length <= 1) {
+    return null;
+  }
+
+  const result = segments.slice(0, -1).join('/');
+  return result || null;
+}
+
+/**
+ * Check if path points to document
+ */
+export function isDocumentPath(path: string): boolean {
+  const segments = path.split('/');
+  return segments.length % 2 === 0 && segments.length >= 2;
+}
+
+/**
+ * Check if path points to collection
+ */
+export function isCollectionPath(path: string): boolean {
+  const segments = path.split('/');
+  return segments.length % 2 !== 0 && segments.length >= 1;
+}
+
+/**
+ * Check if collection is a user collection (users/{userId}/{collection})
+ */
+export function isUserCollectionPath(path: string): boolean {
+  return path.startsWith('users/');
+}
+
+/**
+ * Extract user ID from user collection path
+ */
+export function extractUserIdFromPath(path: string): string | null {
+  if (!isUserCollectionPath(path)) return null;
+
+  const segments = path.split('/');
+  if (segments.length >= 3 && segments[0] === 'users') {
+    const userId = segments[1];
+    return userId || null;
+  }
+
+  return null;
+}
+
+/**
+ * Create a sub-collection path
+ */
+export function createSubCollectionPath(parentPath: string, subCollectionName: string): string | null {
+  if (!isValidCollectionPath(parentPath)) {
+    return null;
+  }
+
+  if (!isValidCollectionName(subCollectionName)) {
+    return null;
+  }
+
+  return `${parentPath}/${subCollectionName}`;
+}

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>);
+}