@umituz/react-native-firebase 1.13.121 → 1.13.122

package/src/firestore/utils/query/filters.util.ts

@@ -0,0 +1,75 @@
+/**
+ * Query Filters Utility
+ * Utilities for creating Firestore field filters
+ */
+
+import {
+  query,
+  where,
+  or,
+  type WhereFilterOp,
+  type Query,
+} from "firebase/firestore";
+
+export interface FieldFilter {
+  field: string;
+  operator: WhereFilterOp;
+  value: string | number | boolean | string[] | number[];
+}
+
+const MAX_IN_OPERATOR_VALUES = 10;
+
+/**
+ * Apply field filter with 'in' operator and chunking support
+ */
+export function applyFieldFilter(q: Query, filter: FieldFilter): Query {
+  const { field, operator, value } = filter;
+
+  if (operator === "in" && Array.isArray(value)) {
+    if (value.length <= MAX_IN_OPERATOR_VALUES) {
+      return query(q, where(field, "in", value));
+    }
+
+    // Split into chunks of 10 and use 'or' operator
+    const chunks: (string[] | number[])[] = [];
+    for (let i = 0; i < value.length; i += MAX_IN_OPERATOR_VALUES) {
+      chunks.push(value.slice(i, i + MAX_IN_OPERATOR_VALUES));
+    }
+
+    const orConditions = chunks.map((chunk) => where(field, "in", chunk));
+    return query(q, or(...orConditions));
+  }
+
+  return query(q, where(field, operator, value));
+}
+
+/**
+ * Create a field filter for 'in' operator
+ */
+export function createInFilter(
+  field: string,
+  values: string[] | number[],
+): FieldFilter {
+  return { field, operator: "in", value: values };
+}
+
+/**
+ * Create a field filter for equality
+ */
+export function createEqualFilter(
+  field: string,
+  value: string | number | boolean,
+): FieldFilter {
+  return { field, operator: "==", value };
+}
+
+/**
+ * Create a field filter for custom operator
+ */
+export function createFieldFilter(
+  field: string,
+  operator: WhereFilterOp,
+  value: string | number | boolean | string[] | number[],
+): FieldFilter {
+  return { field, operator, value };
+}

package/src/firestore/utils/query/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Query Utilities
+ * Utilities for building Firestore queries
+ */
+
+export { applyFieldFilter, createInFilter, createEqualFilter, createFieldFilter } from './filters.util';
+export type { FieldFilter } from './filters.util';
+
+export { applyDateRange, applySort, applyCursor, applyLimit } from './modifiers.util';
+export type { SortOptions, DateRangeOptions } from './modifiers.util';

package/src/firestore/utils/query/modifiers.util.ts

@@ -0,0 +1,65 @@
+/**
+ * Query Modifiers Utility
+ * Utilities for applying query modifiers (sort, limit, cursor)
+ */
+
+import {
+  query,
+  orderBy,
+  where,
+  limit as limitQuery,
+  startAfter,
+  type Query,
+  Timestamp,
+} from "firebase/firestore";
+
+export interface SortOptions {
+  field: string;
+  order?: "asc" | "desc";
+}
+
+export interface DateRangeOptions {
+  field: string;
+  startDate?: number;
+  endDate?: number;
+}
+
+/**
+ * Apply date range filters to query
+ */
+export function applyDateRange(q: Query, dateRange: DateRangeOptions | undefined): Query {
+  if (!dateRange) return q;
+
+  if (dateRange.startDate) {
+    q = query(q, where(dateRange.field, ">=", Timestamp.fromMillis(dateRange.startDate)));
+  }
+  if (dateRange.endDate) {
+    q = query(q, where(dateRange.field, "<=", Timestamp.fromMillis(dateRange.endDate)));
+  }
+  return q;
+}
+
+/**
+ * Apply sorting to query
+ */
+export function applySort(q: Query, sort?: SortOptions): Query {
+  if (!sort) return q;
+  const sortOrder = sort.order || "desc";
+  return query(q, orderBy(sort.field, sortOrder));
+}
+
+/**
+ * Apply cursor for pagination
+ */
+export function applyCursor(q: Query, cursorValue?: number): Query {
+  if (cursorValue === undefined) return q;
+  return query(q, startAfter(Timestamp.fromMillis(cursorValue)));
+}
+
+/**
+ * Apply limit to query
+ */
+export function applyLimit(q: Query, limitValue?: number): Query {
+  if (limitValue === undefined) return q;
+  return query(q, limitQuery(limitValue));
+}

package/src/firestore/utils/query-builder.ts

@@ -5,106 +5,21 @@
 
 import {
   collection,
-  query,
-  where,
-  orderBy,
-  limit as limitQuery,
-  startAfter,
-  or,
   type Firestore,
   type Query,
-  Timestamp,
-  type WhereFilterOp,
 } from "firebase/firestore";
-
-export interface FieldFilter {
-  field: string;
-  operator: WhereFilterOp;
-  value: string | number | boolean | string[] | number[];
-}
+import { applyFieldFilter, createInFilter, createEqualFilter, createFieldFilter, type FieldFilter } from "./query/filters.util";
+import { applyDateRange, applySort, applyCursor, applyLimit, type SortOptions, type DateRangeOptions } from "./query/modifiers.util";
 
 export interface QueryBuilderOptions {
   collectionName: string;
   baseFilters?: FieldFilter[];
-  dateRange?: {
-    field: string;
-    startDate?: number;
-    endDate?: number;
-  };
-  sort?: {
-    field: string;
-    order?: "asc" | "desc";
-  };
+  dateRange?: DateRangeOptions;
+  sort?: SortOptions;
   limitValue?: number;
   cursorValue?: number;
 }
 
-const MAX_IN_OPERATOR_VALUES = 10;
-
-/**
- * Apply date range filters to query
- */
-function applyDateRange(q: Query, dateRange: QueryBuilderOptions['dateRange']): Query {
-  if (!dateRange) return q;
-
-  if (dateRange.startDate) {
-    q = query(q, where(dateRange.field, ">=", Timestamp.fromMillis(dateRange.startDate)));
-  }
-  if (dateRange.endDate) {
-    q = query(q, where(dateRange.field, "<=", Timestamp.fromMillis(dateRange.endDate)));
-  }
-  return q;
-}
-
-/**
- * Apply sorting to query
- */
-function applySort(q: Query, sort?: QueryBuilderOptions['sort']): Query {
-  if (!sort) return q;
-  const sortOrder = sort.order || "desc";
-  return query(q, orderBy(sort.field, sortOrder));
-}
-
-/**
- * Apply cursor for pagination
- */
-function applyCursor(q: Query, cursorValue?: number): Query {
-  if (cursorValue === undefined) return q;
-  return query(q, startAfter(Timestamp.fromMillis(cursorValue)));
-}
-
-/**
- * Apply limit to query
- */
-function applyLimit(q: Query, limitValue?: number): Query {
-  if (limitValue === undefined) return q;
-  return query(q, limitQuery(limitValue));
-}
-
-/**
- * Apply field filter with 'in' operator and chunking support
- */
-function applyFieldFilter(q: Query, filter: FieldFilter): Query {
-  const { field, operator, value } = filter;
-
-  if (operator === "in" && Array.isArray(value)) {
-    if (value.length <= MAX_IN_OPERATOR_VALUES) {
-      return query(q, where(field, "in", value));
-    }
-
-    // Split into chunks of 10 and use 'or' operator
-    const chunks: (string[] | number[])[] = [];
-    for (let i = 0; i < value.length; i += MAX_IN_OPERATOR_VALUES) {
-      chunks.push(value.slice(i, i + MAX_IN_OPERATOR_VALUES));
-    }
-
-    const orConditions = chunks.map((chunk) => where(field, "in", chunk));
-    return query(q, or(...orConditions));
-  }
-
-  return query(q, where(field, operator, value));
-}
-
 /**
  * Build Firestore query with advanced filtering support
  */
@@ -138,22 +53,6 @@ export function buildQuery(
   return q;
 }
 
-/**
- * Create a field filter for 'in' operator
- */
-export function createInFilter(
-  field: string,
-  values: string[] | number[],
-): FieldFilter {
-  return { field, operator: "in", value: values };
-}
-
-/**
- * Create a field filter for equality
- */
-export function createEqualFilter(
-  field: string,
-  value: string | number | boolean,
-): FieldFilter {
-  return { field, operator: "==", value };
-}
+// Re-export filter utilities for convenience
+export { createInFilter, createEqualFilter, createFieldFilter };
+export type { FieldFilter, SortOptions, DateRangeOptions };

package/src/firestore/utils/result/result.util.ts

@@ -0,0 +1,45 @@
+/**
+ * Result Utility
+ * Utilities for creating Firestore result objects
+ */
+
+export interface FirestoreResult<T> {
+  success: boolean;
+  data?: T;
+  error?: { message: string; code: string };
+}
+
+export type NoDbResult = FirestoreResult<never>;
+
+export const NO_DB_ERROR: NoDbResult = {
+  success: false,
+  error: { message: "No DB", code: "DB_ERR" },
+};
+
+/**
+ * Create a standard error result
+ */
+export function createErrorResult<T>(message: string, code: string): FirestoreResult<T> {
+  return { success: false, error: { message, code } };
+}
+
+/**
+ * Create a standard success result
+ */
+export function createSuccessResult<T>(data?: T): FirestoreResult<T> {
+  return { success: true, data };
+}
+
+/**
+ * Check if result is successful
+ */
+export function isSuccess<T>(result: FirestoreResult<T>): result is FirestoreResult<T> & { success: true } {
+  return result.success;
+}
+
+/**
+ * Check if result is an error
+ */
+export function isError<T>(result: FirestoreResult<T>): result is FirestoreResult<T> & { success: false } {
+  return !result.success;
+}

package/src/firestore/utils/transaction/transaction.util.ts

@@ -0,0 +1,45 @@
+/**
+ * Transaction Utility
+ * Utilities for executing Firestore transactions
+ */
+
+import {
+  runTransaction as fbRunTransaction,
+  serverTimestamp as fbServerTimestamp,
+  type Transaction,
+} from "firebase/firestore";
+import { getDb } from "../firestore-helper";
+import type { Firestore } from "../../infrastructure/config/FirestoreClient";
+
+/**
+ * Execute a transaction with automatic DB instance check.
+ * Wraps the Firebase runTransaction to ensure the DB is initialized.
+ */
+export async function runTransaction<T>(
+  updateFunction: (transaction: Transaction) => Promise<T>
+): Promise<T> {
+  const db = getDb();
+  if (!db) {
+    throw new Error("[runTransaction] Firestore database is not initialized. Please ensure Firebase is properly initialized before running transactions.");
+  }
+  try {
+    return await fbRunTransaction(db as Firestore, updateFunction);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+    const errorCode = error instanceof Error ? (error as { code?: string }).code : 'unknown';
+
+    if (__DEV__) {
+      console.error(`[runTransaction] Transaction failed (Code: ${errorCode}):`, errorMessage);
+    }
+
+    throw new Error(`[runTransaction] Transaction failed: ${errorMessage} (Code: ${errorCode})`);
+  }
+}
+
+/**
+ * Get the server timestamp (Sentinel value).
+ * Wraps Firebase serverTimestamp to avoid direct dependency.
+ */
+export function serverTimestamp() {
+  return fbServerTimestamp();
+}

package/src/index.ts

@@ -8,7 +8,6 @@
  * Module-specific exports available via:
  * - @umituz/react-native-firebase/auth
  * - @umituz/react-native-firebase/firestore
- * - @umituz/react-native-firebase/storage
  */
 
 // Core Errors

package/src/infrastructure/config/FirebaseConfigLoader.ts

@@ -7,6 +7,11 @@
  */
 
 import type { FirebaseConfig } from '../../domain/value-objects/FirebaseConfig';
+import {
+  isValidString,
+  isValidFirebaseApiKey,
+  isValidFirebaseAuthDomain,
+} from '../../domain/utils/validation.util';
 
 type ConfigKey = 'apiKey' | 'authDomain' | 'projectId' | 'storageBucket' | 'messagingSenderId' | 'appId';
 
@@ -27,7 +32,7 @@ function getEnvValue(key: ConfigKey): string {
   const keys = ENV_KEYS[key];
   for (const envKey of keys) {
     const value = process.env[`${EXPO_PREFIX}${envKey}`] || process.env[envKey];
-    if (value?.trim()) return value;
+    if (isValidString(value)) return value;
   }
   return '';
 }
@@ -62,15 +67,6 @@ function getExpoValue(key: ConfigKey, expoConfig: Record<string, string>): strin
   return expoConfig[mapping[key]] || '';
 }
 
-/**
- * Validate Firebase API key format
- */
-function validateApiKey(apiKey: string): boolean {
-  // Firebase API keys typically start with "AIza" followed by 35 characters
-  const apiKeyPattern = /^AIza[0-9A-Za-z_-]{35}$/;
-  return apiKeyPattern.test(apiKey);
-}
-
 /**
  * Load Firebase configuration from Constants and environment variables
  */
@@ -90,7 +86,7 @@ export function loadFirebaseConfig(): FirebaseConfig | null {
   const authDomain = config.authDomain?.trim();
   const projectId = config.projectId?.trim();
 
-  if (!apiKey || !authDomain || !projectId) {
+  if (!isValidString(apiKey) || !isValidString(authDomain) || !isValidString(projectId)) {
     if (__DEV__) {
       console.error('[FirebaseConfigLoader] Missing required configuration fields');
     }
@@ -98,7 +94,7 @@ export function loadFirebaseConfig(): FirebaseConfig | null {
   }
 
   // Validate API key format
-  if (!validateApiKey(apiKey)) {
+  if (!isValidFirebaseApiKey(apiKey)) {
     if (__DEV__) {
       console.error('[FirebaseConfigLoader] Invalid API key format');
     }
@@ -106,7 +102,7 @@ export function loadFirebaseConfig(): FirebaseConfig | null {
   }
 
   // Validate authDomain format (should be like "projectId.firebaseapp.com")
-  if (!authDomain.includes('.firebaseapp.com') && !authDomain.includes('.web.app')) {
+  if (!isValidFirebaseAuthDomain(authDomain)) {
     if (__DEV__) {
       console.warn('[FirebaseConfigLoader] Unusual authDomain format, expected "projectId.firebaseapp.com" or similar');
     }