@umituz/react-native-firebase 2.6.1 → 2.6.3

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

@@ -1,207 +1,101 @@
 /**
  * Where Clause Factory
- * Single Responsibility: Provide factory methods for common where clauses
- *
- * Factory functions for creating commonly used where clauses.
- * Separated from WhereClause for better maintainability.
+ * Single Responsibility: Create where clauses
  *
  * Max lines: 150 (enforced for maintainability)
  */
 
 import type { WhereFilterOp } from 'firebase/firestore';
 import { WhereClause } from './WhereClause';
-import type { WhereOperator } from './WhereClause';
-
-/**
- * Factory function to create where clause
- */
-export function createWhereClause(
-  field: string,
-  operator: WhereFilterOp,
-  value: unknown
-): WhereClause {
-  return WhereClause.create(field, operator, value);
-}
-
-/**
- * Factory functions for common where clauses
- */
-export const where = {
-  equals: WhereClause.equals,
-  notEquals: WhereClause.notEquals,
-  lessThan: WhereClause.lessThan,
-  lessThanOrEqual: WhereClause.lessThanOrEqual,
-  greaterThan: WhereClause.greaterThan,
-  greaterThanOrEqual: WhereClause.greaterThanOrEqual,
-  arrayContains: WhereClause.arrayContains,
-  arrayContainsAny: WhereClause.arrayContainsAny,
-  in: WhereClause.in,
-  notIn: WhereClause.notIn,
-};
-
-/**
- * Create batch of where clauses
- */
-export function createWhereBatch(
-  clauses: Array<{ field: string; operator: WhereFilterOp; value: unknown }>
-): WhereClause[] {
-  return clauses.map(c => WhereClause.create(c.field, c.operator, c.value));
-}
 
 /**
- * Create equality clauses from object
+ * Create equals where clause
  */
-export function createEqualityFilters(obj: Record<string, unknown>): WhereClause[] {
-  return Object.entries(obj).map(([field, value]) =>
-    WhereClause.equals(field, value)
-  );
+export function equals(field: string, value: unknown): WhereClause {
+  return new WhereClause(field, '==', value);
 }
 
 /**
- * Create in clause from values
+ * Create not-equals where clause
  */
-export function createInClause(field: string, values: unknown[]): WhereClause {
-  return WhereClause.in(field, values);
+export function notEquals(field: string, value: unknown): WhereClause {
+  return new WhereClause(field, '!=', value);
 }
 
 /**
- * Create not-in clause from values
+ * Create less-than where clause
  */
-export function createNotInClause(field: string, values: unknown[]): WhereClause {
-  return WhereClause.notIn(field, values);
+export function lessThan(field: string, value: unknown): WhereClause {
+  return new WhereClause(field, '<', value);
 }
 
 /**
- * Create range clause (>= start and <= end)
+ * Create less-than-or-equal where clause
  */
-export function createRangeClause(
-  field: string,
-  startValue: unknown,
-  endValue: unknown
-): WhereClause[] {
-  return [
-    WhereClause.greaterThanOrEqual(field, startValue),
-    WhereClause.lessThanOrEqual(field, endValue),
-  ];
+export function lessThanOrEqual(field: string, value: unknown): WhereClause {
+  return new WhereClause(field, '<=', value);
 }
 
 /**
- * Create date range clause
+ * Create greater-than where clause
  */
-export function createDateRangeClause(
-  field: string,
-  startDate: Date,
-  endDate: Date
-): WhereClause[] {
-  return createRangeClause(field, startDate, endDate);
+export function greaterThan(field: string, value: unknown): WhereClause {
+  return new WhereClause(field, '>', value);
 }
 
 /**
- * Create text search clause (case-insensitive contains)
- * Note: Firestore doesn't support native contains, this is for consistency
+ * Create greater-than-or-equal where clause
  */
-export function createTextSearchClause(field: string, searchText: string): WhereClause {
-  return WhereClause.equals(field, searchText);
+export function greaterThanOrEqual(field: string, value: unknown): WhereClause {
+  return new WhereClause(field, '>=', value);
 }
 
 /**
- * Create multiple equality clauses combined
+ * Create array-contains where clause
  */
-export function createMultiFieldFilter(filters: Record<string, unknown>): WhereClause[] {
-  return createEqualityFilters(filters);
+export function arrayContains(field: string, value: unknown): WhereClause {
+  return new WhereClause(field, 'array-contains', value);
 }
 
 /**
- * Create not-null clause
+ * Create in where clause
  */
-export function createNotNullClause(field: string): WhereClause {
-  return WhereClause.notEquals(field, null);
+export function inOp(field: string, values: unknown[]): WhereClause {
+  return new WhereClause(field, 'in', values);
 }
 
 /**
- * Create null clause
+ * Create not-in where clause
  */
-export function createNullClause(field: string): WhereClause {
-  return WhereClause.equals(field, null);
+export function notIn(field: string, values: unknown[]): WhereClause {
+  return new WhereClause(field, 'not-in', values);
 }
 
 /**
- * Create boolean clause
+ * Create array-contains-any where clause
  */
-export function createBooleanClause(field: string, value: boolean): WhereClause {
-  return WhereClause.equals(field, value);
+export function arrayContainsAny(field: string, values: unknown[]): WhereClause {
+  return new WhereClause(field, 'array-contains-any', values);
 }
 
 /**
- * Create number range clause
+ * Create where clause with custom operator
  */
-export function createNumberRangeClause(
+export function where(
   field: string,
-  min: number,
-  max: number
-): WhereClause[] {
-  return [
-    WhereClause.greaterThanOrEqual(field, min),
-    WhereClause.lessThanOrEqual(field, max),
-  ];
-}
-
-/**
- * Validate where clauses compatibility
- */
-export function validateWhereClauses(clauses: WhereClause[]): {
-  valid: boolean;
-  errors: string[];
-} {
-  const errors: string[] = [];
-
-  // Validate each clause individually
-  for (let i = 0; i < clauses.length; i++) {
-    const validation = clauses[i].validate();
-    if (!validation.valid) {
-      errors.push(`Clause ${i}: ${validation.errors.join(', ')}`);
-    }
-  }
-
-  // Validate compatibility
-  for (let i = 0; i < clauses.length; i++) {
-    for (let j = i + 1; j < clauses.length; j++) {
-      if (!clauses[i].isCompatibleWith(clauses[j])) {
-        errors.push(`Clauses ${i} and ${j} are incompatible`);
-      }
-    }
-  }
-
-  return {
-    valid: errors.length === 0,
-    errors,
-  };
+  operator: WhereFilterOp,
+  value: unknown
+): WhereClause {
+  return new WhereClause(field, operator, value);
 }
 
 /**
- * Optimize where clauses
- * Removes duplicates and incompatible clauses
+ * Create where clause from object
  */
-export function optimizeWhereClauses(clauses: WhereClause[]): WhereClause[] {
-  // Remove duplicates
-  const unique = clauses.filter((clause, index, self) =>
-    index === self.findIndex(c => clause.equals(c))
-  );
-
-  // Remove incompatible (keep first occurrences)
-  const compatible: WhereClause[] = [];
-  for (const clause of unique) {
-    let canAdd = true;
-    for (const existing of compatible) {
-      if (!clause.isCompatibleWith(existing)) {
-        canAdd = false;
-        break;
-      }
-    }
-    if (canAdd) {
-      compatible.push(clause);
-    }
-  }
-
-  return compatible;
+export function fromObject(obj: {
+  field: string;
+  operator: WhereFilterOp;
+  value: unknown;
+}): WhereClause {
+  return new WhereClause(obj.field, obj.operator, obj.value);
 }

package/src/domains/firestore/domain/value-objects/WhereClauseFactory.ts.bak

@@ -0,0 +1,207 @@
+/**
+ * Where Clause Factory
+ * Single Responsibility: Provide factory methods for common where clauses
+ *
+ * Factory functions for creating commonly used where clauses.
+ * Separated from WhereClause for better maintainability.
+ *
+ * Max lines: 150 (enforced for maintainability)
+ */
+
+import type { WhereFilterOp } from 'firebase/firestore';
+import { WhereClause } from './WhereClause';
+import type { WhereOperator } from './WhereClause';
+
+/**
+ * Factory function to create where clause
+ */
+export function createWhereClause(
+  field: string,
+  operator: WhereFilterOp,
+  value: unknown
+): WhereClause {
+  return WhereClause.create(field, operator, value);
+}
+
+/**
+ * Factory functions for common where clauses
+ */
+export const where = {
+  equals: WhereClause.equals,
+  notEquals: WhereClause.notEquals,
+  lessThan: WhereClause.lessThan,
+  lessThanOrEqual: WhereClause.lessThanOrEqual,
+  greaterThan: WhereClause.greaterThan,
+  greaterThanOrEqual: WhereClause.greaterThanOrEqual,
+  arrayContains: WhereClause.arrayContains,
+  arrayContainsAny: WhereClause.arrayContainsAny,
+  in: WhereClause.in,
+  notIn: WhereClause.notIn,
+};
+
+/**
+ * Create batch of where clauses
+ */
+export function createWhereBatch(
+  clauses: Array<{ field: string; operator: WhereFilterOp; value: unknown }>
+): WhereClause[] {
+  return clauses.map(c => WhereClause.create(c.field, c.operator, c.value));
+}
+
+/**
+ * Create equality clauses from object
+ */
+export function createEqualityFilters(obj: Record<string, unknown>): WhereClause[] {
+  return Object.entries(obj).map(([field, value]) =>
+    WhereClause.equals(field, value)
+  );
+}
+
+/**
+ * Create in clause from values
+ */
+export function createInClause(field: string, values: unknown[]): WhereClause {
+  return WhereClause.in(field, values);
+}
+
+/**
+ * Create not-in clause from values
+ */
+export function createNotInClause(field: string, values: unknown[]): WhereClause {
+  return WhereClause.notIn(field, values);
+}
+
+/**
+ * Create range clause (>= start and <= end)
+ */
+export function createRangeClause(
+  field: string,
+  startValue: unknown,
+  endValue: unknown
+): WhereClause[] {
+  return [
+    WhereClause.greaterThanOrEqual(field, startValue),
+    WhereClause.lessThanOrEqual(field, endValue),
+  ];
+}
+
+/**
+ * Create date range clause
+ */
+export function createDateRangeClause(
+  field: string,
+  startDate: Date,
+  endDate: Date
+): WhereClause[] {
+  return createRangeClause(field, startDate, endDate);
+}
+
+/**
+ * Create text search clause (case-insensitive contains)
+ * Note: Firestore doesn't support native contains, this is for consistency
+ */
+export function createTextSearchClause(field: string, searchText: string): WhereClause {
+  return WhereClause.equals(field, searchText);
+}
+
+/**
+ * Create multiple equality clauses combined
+ */
+export function createMultiFieldFilter(filters: Record<string, unknown>): WhereClause[] {
+  return createEqualityFilters(filters);
+}
+
+/**
+ * Create not-null clause
+ */
+export function createNotNullClause(field: string): WhereClause {
+  return WhereClause.notEquals(field, null);
+}
+
+/**
+ * Create null clause
+ */
+export function createNullClause(field: string): WhereClause {
+  return WhereClause.equals(field, null);
+}
+
+/**
+ * Create boolean clause
+ */
+export function createBooleanClause(field: string, value: boolean): WhereClause {
+  return WhereClause.equals(field, value);
+}
+
+/**
+ * Create number range clause
+ */
+export function createNumberRangeClause(
+  field: string,
+  min: number,
+  max: number
+): WhereClause[] {
+  return [
+    WhereClause.greaterThanOrEqual(field, min),
+    WhereClause.lessThanOrEqual(field, max),
+  ];
+}
+
+/**
+ * Validate where clauses compatibility
+ */
+export function validateWhereClauses(clauses: WhereClause[]): {
+  valid: boolean;
+  errors: string[];
+} {
+  const errors: string[] = [];
+
+  // Validate each clause individually
+  for (let i = 0; i < clauses.length; i++) {
+    const validation = clauses[i].validate();
+    if (!validation.valid) {
+      errors.push(`Clause ${i}: ${validation.errors.join(', ')}`);
+    }
+  }
+
+  // Validate compatibility
+  for (let i = 0; i < clauses.length; i++) {
+    for (let j = i + 1; j < clauses.length; j++) {
+      if (!clauses[i].isCompatibleWith(clauses[j])) {
+        errors.push(`Clauses ${i} and ${j} are incompatible`);
+      }
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+  };
+}
+
+/**
+ * Optimize where clauses
+ * Removes duplicates and incompatible clauses
+ */
+export function optimizeWhereClauses(clauses: WhereClause[]): WhereClause[] {
+  // Remove duplicates
+  const unique = clauses.filter((clause, index, self) =>
+    index === self.findIndex(c => clause.equals(c))
+  );
+
+  // Remove incompatible (keep first occurrences)
+  const compatible: WhereClause[] = [];
+  for (const clause of unique) {
+    let canAdd = true;
+    for (const existing of compatible) {
+      if (!clause.isCompatibleWith(existing)) {
+        canAdd = false;
+        break;
+      }
+    }
+    if (canAdd) {
+      compatible.push(clause);
+    }
+  }
+
+  return compatible;
+}

package/src/domains/firestore/domain/value-objects/WhereClauseFactory_part_aa

@@ -0,0 +1,150 @@
+/**
+ * Where Clause Factory
+ * Single Responsibility: Provide factory methods for common where clauses
+ *
+ * Factory functions for creating commonly used where clauses.
+ * Separated from WhereClause for better maintainability.
+ *
+ * Max lines: 150 (enforced for maintainability)
+ */
+
+import type { WhereFilterOp } from 'firebase/firestore';
+import { WhereClause } from './WhereClause';
+import type { WhereOperator } from './WhereClause';
+
+/**
+ * Factory function to create where clause
+ */
+export function createWhereClause(
+  field: string,
+  operator: WhereFilterOp,
+  value: unknown
+): WhereClause {
+  return WhereClause.create(field, operator, value);
+}
+
+/**
+ * Factory functions for common where clauses
+ */
+export const where = {
+  equals: WhereClause.equals,
+  notEquals: WhereClause.notEquals,
+  lessThan: WhereClause.lessThan,
+  lessThanOrEqual: WhereClause.lessThanOrEqual,
+  greaterThan: WhereClause.greaterThan,
+  greaterThanOrEqual: WhereClause.greaterThanOrEqual,
+  arrayContains: WhereClause.arrayContains,
+  arrayContainsAny: WhereClause.arrayContainsAny,
+  in: WhereClause.in,
+  notIn: WhereClause.notIn,
+};
+
+/**
+ * Create batch of where clauses
+ */
+export function createWhereBatch(
+  clauses: Array<{ field: string; operator: WhereFilterOp; value: unknown }>
+): WhereClause[] {
+  return clauses.map(c => WhereClause.create(c.field, c.operator, c.value));
+}
+
+/**
+ * Create equality clauses from object
+ */
+export function createEqualityFilters(obj: Record<string, unknown>): WhereClause[] {
+  return Object.entries(obj).map(([field, value]) =>
+    WhereClause.equals(field, value)
+  );
+}
+
+/**
+ * Create in clause from values
+ */
+export function createInClause(field: string, values: unknown[]): WhereClause {
+  return WhereClause.in(field, values);
+}
+
+/**
+ * Create not-in clause from values
+ */
+export function createNotInClause(field: string, values: unknown[]): WhereClause {
+  return WhereClause.notIn(field, values);
+}
+
+/**
+ * Create range clause (>= start and <= end)
+ */
+export function createRangeClause(
+  field: string,
+  startValue: unknown,
+  endValue: unknown
+): WhereClause[] {
+  return [
+    WhereClause.greaterThanOrEqual(field, startValue),
+    WhereClause.lessThanOrEqual(field, endValue),
+  ];
+}
+
+/**
+ * Create date range clause
+ */
+export function createDateRangeClause(
+  field: string,
+  startDate: Date,
+  endDate: Date
+): WhereClause[] {
+  return createRangeClause(field, startDate, endDate);
+}
+
+/**
+ * Create text search clause (case-insensitive contains)
+ * Note: Firestore doesn't support native contains, this is for consistency
+ */
+export function createTextSearchClause(field: string, searchText: string): WhereClause {
+  return WhereClause.equals(field, searchText);
+}
+
+/**
+ * Create multiple equality clauses combined
+ */
+export function createMultiFieldFilter(filters: Record<string, unknown>): WhereClause[] {
+  return createEqualityFilters(filters);
+}
+
+/**
+ * Create not-null clause
+ */
+export function createNotNullClause(field: string): WhereClause {
+  return WhereClause.notEquals(field, null);
+}
+
+/**
+ * Create null clause
+ */
+export function createNullClause(field: string): WhereClause {
+  return WhereClause.equals(field, null);
+}
+
+/**
+ * Create boolean clause
+ */
+export function createBooleanClause(field: string, value: boolean): WhereClause {
+  return WhereClause.equals(field, value);
+}
+
+/**
+ * Create number range clause
+ */
+export function createNumberRangeClause(
+  field: string,
+  min: number,
+  max: number
+): WhereClause[] {
+  return [
+    WhereClause.greaterThanOrEqual(field, min),
+    WhereClause.lessThanOrEqual(field, max),
+  ];
+}
+
+/**
+ * Validate where clauses compatibility

package/src/domains/firestore/domain/value-objects/WhereClauseFactory_part_ab

@@ -0,0 +1,57 @@
+ */
+export function validateWhereClauses(clauses: WhereClause[]): {
+  valid: boolean;
+  errors: string[];
+} {
+  const errors: string[] = [];
+
+  // Validate each clause individually
+  for (let i = 0; i < clauses.length; i++) {
+    const validation = clauses[i].validate();
+    if (!validation.valid) {
+      errors.push(`Clause ${i}: ${validation.errors.join(', ')}`);
+    }
+  }
+
+  // Validate compatibility
+  for (let i = 0; i < clauses.length; i++) {
+    for (let j = i + 1; j < clauses.length; j++) {
+      if (!clauses[i].isCompatibleWith(clauses[j])) {
+        errors.push(`Clauses ${i} and ${j} are incompatible`);
+      }
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+  };
+}
+
+/**
+ * Optimize where clauses
+ * Removes duplicates and incompatible clauses
+ */
+export function optimizeWhereClauses(clauses: WhereClause[]): WhereClause[] {
+  // Remove duplicates
+  const unique = clauses.filter((clause, index, self) =>
+    index === self.findIndex(c => clause.equals(c))
+  );
+
+  // Remove incompatible (keep first occurrences)
+  const compatible: WhereClause[] = [];
+  for (const clause of unique) {
+    let canAdd = true;
+    for (const existing of compatible) {
+      if (!clause.isCompatibleWith(existing)) {
+        canAdd = false;
+        break;
+      }
+    }
+    if (canAdd) {
+      compatible.push(clause);
+    }
+  }
+
+  return compatible;
+}