@umituz/react-native-firebase 3.0.3 → 3.0.6

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

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

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

@@ -1,138 +0,0 @@
-/**
- * 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/index.ts

@@ -1,61 +0,0 @@
-/**
- * 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 } from './entities/Collection';
-export { fromReference, fromQuery, createCollection } from './entities/CollectionFactory';
-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 type { SortOptions, DateRangeOptions, PaginationOptions } from './value-objects/QueryOptions';
-
-// Where Clause
-export { WhereClause } from './value-objects/WhereClause';
-export { equals, where, fromObject as createWhereClause } from './value-objects/WhereClauseFactory';
-export type { WhereOperator } from './value-objects/WhereClause';

package/src/domains/firestore/domain/value-objects/QueryOptions.ts

@@ -1,143 +0,0 @@
-/**
- * Query Options Value Object (Main)
- * Single Responsibility: Encapsulate query configuration options
- *
- * Max lines: 150 (enforced for maintainability)
- */
-
-import type { OrderByDirection } from 'firebase/firestore';
-import { WhereClause } from './WhereClause';
-import * as Factory from './QueryOptionsFactory';
-
-export interface SortOptions {
-  readonly field: string;
-  readonly direction: OrderByDirection;
-}
-
-export interface DateRangeOptions {
-  readonly field: string;
-  readonly startDate?: Date;
-  readonly endDate?: Date;
-}
-
-export interface PaginationOptions {
-  readonly cursor?: number;
-  readonly limit?: number;
-  readonly startAfter?: number;
-  readonly startAt?: number;
-}
-
-export class QueryOptions {
-  readonly whereClauses: readonly WhereClause[];
-  readonly sortOptions: readonly SortOptions[];
-  readonly dateRange: DateRangeOptions | null;
-  readonly pagination: PaginationOptions | null;
-
-  private constructor(
-    whereClauses: WhereClause[],
-    sortOptions: SortOptions[],
-    dateRange: DateRangeOptions | null,
-    pagination: PaginationOptions | null
-  ) {
-    this.whereClauses = Object.freeze(whereClauses);
-    this.sortOptions = Object.freeze(sortOptions);
-    this.dateRange = dateRange ? Object.freeze(dateRange) : null;
-    this.pagination = pagination ? Object.freeze(pagination) : null;
-  }
-
-  static empty(): QueryOptions {
-    return new QueryOptions([], [], null, null);
-  }
-
-  static create(options: {
-    where?: WhereClause[];
-    sort?: SortOptions[];
-    dateRange?: DateRangeOptions;
-    pagination?: PaginationOptions;
-  }): QueryOptions {
-    return new QueryOptions(
-      options.where || [],
-      options.sort || [],
-      options.dateRange || null,
-      options.pagination || null
-    );
-  }
-
-  withWhere(clause: WhereClause): QueryOptions {
-    return new QueryOptions(
-      [...this.whereClauses, clause] as WhereClause[],
-      [...this.sortOptions] as SortOptions[],
-      this.dateRange,
-      this.pagination
-    );
-  }
-
-  withSort(sort: SortOptions): QueryOptions {
-    return new QueryOptions(
-      [...this.whereClauses] as WhereClause[],
-      [...this.sortOptions, sort] as SortOptions[],
-      this.dateRange,
-      this.pagination
-    );
-  }
-
-  withDateRange(dateRange: DateRangeOptions): QueryOptions {
-    return new QueryOptions(
-      [...this.whereClauses] as WhereClause[],
-      [...this.sortOptions] as SortOptions[],
-      dateRange,
-      this.pagination
-    );
-  }
-
-  withPagination(pagination: PaginationOptions): QueryOptions {
-    return new QueryOptions(
-      [...this.whereClauses] as WhereClause[],
-      [...this.sortOptions] as SortOptions[],
-      this.dateRange,
-      pagination
-    );
-  }
-
-  withLimit(limit: number): QueryOptions {
-    return this.withPagination({
-      ...this.pagination,
-      limit,
-    } as PaginationOptions);
-  }
-
-  clearWhere(): QueryOptions {
-    return new QueryOptions([], [...this.sortOptions] as SortOptions[], this.dateRange, this.pagination);
-  }
-
-  clearSort(): QueryOptions {
-    return new QueryOptions([...this.whereClauses] as WhereClause[], [], this.dateRange, this.pagination);
-  }
-
-  clearDateRange(): QueryOptions {
-    return new QueryOptions([...this.whereClauses] as WhereClause[], [...this.sortOptions] as SortOptions[], null, this.pagination);
-  }
-
-  clearPagination(): QueryOptions {
-    return new QueryOptions([...this.whereClauses] as WhereClause[], [...this.sortOptions] as SortOptions[], this.dateRange, null);
-  }
-
-  clone(modifications: {
-    where?: WhereClause[];
-    sort?: SortOptions[];
-    dateRange?: DateRangeOptions | null;
-    pagination?: PaginationOptions | null;
-  }): QueryOptions {
-    return Factory.clone(this, modifications);
-  }
-}
-
-// Factory function
-export function createQueryOptions(options?: {
-  where?: WhereClause[];
-  sort?: SortOptions[];
-  dateRange?: DateRangeOptions;
-  pagination?: PaginationOptions;
-}): QueryOptions {
-  return options ? QueryOptions.create(options) : QueryOptions.empty();
-}

package/src/domains/firestore/domain/value-objects/QueryOptionsFactory.ts

@@ -1,95 +0,0 @@
-/**
- * Query Options Factory
- * Single Responsibility: Create query options
- *
- * Max lines: 150 (enforced for maintainability)
- */
-
-import type { WhereFilterOp, OrderByDirection } from 'firebase/firestore';
-import type { SortOptions, DateRangeOptions, PaginationOptions } from './QueryOptions';
-import { WhereClause } from './WhereClause';
-import { QueryOptions } from './QueryOptions';
-
-/**
- * Create empty query options
- */
-export function empty(): QueryOptions {
-  return QueryOptions.empty();
-}
-
-/**
- * Create query options from partial configuration
- */
-export function create(options: {
-  where?: WhereClause[];
-  sort?: SortOptions[];
-  dateRange?: DateRangeOptions;
-  pagination?: PaginationOptions;
-}): QueryOptions {
-  return QueryOptions.create(options);
-}
-
-/**
- * Create query options with where clause
- */
-export function withWhere(
-  baseOptions: QueryOptions,
-  field: string,
-  operator: WhereFilterOp,
-  value: unknown
-): QueryOptions {
-  const clause = new WhereClause(field, operator, value);
-  return baseOptions.withWhere(clause);
-}
-
-/**
- * Create query options with sort
- */
-export function withSort(
-  baseOptions: QueryOptions,
-  field: string,
-  direction: OrderByDirection
-): QueryOptions {
-  return baseOptions.withSort({ field, direction });
-}
-
-/**
- * Create query options with date range
- */
-export function withDateRange(
-  baseOptions: QueryOptions,
-  field: string,
-  startDate?: Date,
-  endDate?: Date
-): QueryOptions {
-  return baseOptions.withDateRange({ field, startDate, endDate });
-}
-
-/**
- * Create query options with pagination
- */
-export function withPagination(
-  baseOptions: QueryOptions,
-  pagination: PaginationOptions
-): QueryOptions {
-  return baseOptions.withPagination(pagination);
-}
-
-/**
- * Create query options with limit
- */
-export function withLimit(baseOptions: QueryOptions, limit: number): QueryOptions {
-  return baseOptions.withLimit(limit);
-}
-
-/**
- * Clone query options with modifications
- */
-export function clone(baseOptions: QueryOptions, modifications: {
-  where?: WhereClause[];
-  sort?: SortOptions[];
-  dateRange?: DateRangeOptions | null;
-  pagination?: PaginationOptions | null;
-}): QueryOptions {
-  return baseOptions.clone(modifications);
-}