Pipeline tests part 3

Firestore/Source/API/FIRPipelineBridge.mm

@@ -73,7 +73,9 @@
 using firebase::firestore::api::Union;
 using firebase::firestore::api::Unnest;
 using firebase::firestore::api::Where;
+using firebase::firestore::model::DeepClone;
 using firebase::firestore::model::FieldPath;
+using firebase::firestore::nanopb::MakeSharedMessage;
 using firebase::firestore::nanopb::SharedMessage;
 using firebase::firestore::util::ComparisonResult;
 using firebase::firestore::util::MakeCallback;
@@ -94,13 +96,24 @@ @implementation FIRExprBridge
 @end
 
 @implementation FIRFieldBridge {
+  FIRFieldPath *field_path;
   std::shared_ptr<Field> field;
 }
 
-- (id)init:(NSString *)name {
+- (id)initWithName:(NSString *)name {
   self = [super init];
   if (self) {
-    field = std::make_shared<Field>(MakeString(name));
+    field_path = [FIRFieldPath pathWithDotSeparatedString:name];
+    field = std::make_shared<Field>([field_path internalValue].CanonicalString());
+  }
+  return self;
+}
+
+- (id)initWithPath:(FIRFieldPath *)path {
+  self = [super init];
+  if (self) {
+    field_path = path;
+    field = std::make_shared<Field>([field_path internalValue].CanonicalString());
   }
   return self;
 }
@@ -109,6 +122,10 @@ - (id)init:(NSString *)name {
   return field;
 }
 
+- (NSString *)field_name {
+  return MakeNSString([field_path internalValue].CanonicalString());
+}
+
 @end
 
 @implementation FIRConstantBridge {
@@ -560,7 +577,7 @@ @implementation FIRFindNearestStageBridge {
   FIRVectorValue *_vectorValue;
   NSString *_distanceMeasure;
   NSNumber *_limit;
-  NSString *_Nullable _distanceField;
+  FIRExprBridge *_Nullable _distanceField;
   Boolean isUserDataRead;
   std::shared_ptr<FindNearestStage> cpp_find_nearest;
 }
@@ -569,7 +586,7 @@ - (id)initWithField:(FIRFieldBridge *)field
         vectorValue:(FIRVectorValue *)vectorValue
     distanceMeasure:(NSString *)distanceMeasure
               limit:(NSNumber *_Nullable)limit
-      distanceField:(NSString *_Nullable)distanceField {
+      distanceField:(FIRExprBridge *_Nullable)distanceField {
   self = [super init];
   if (self) {
     _field = field;
@@ -584,21 +601,16 @@ - (id)initWithField:(FIRFieldBridge *)field
 
 - (std::shared_ptr<api::Stage>)cppStageWithReader:(FSTUserDataReader *)reader {
   if (!isUserDataRead) {
-    std::unordered_map<std::string,
-                       nanopb::SharedMessage<firebase::firestore::google_firestore_v1_Value>>
-        optional_value;
+    std::unordered_map<std::string, firebase::firestore::google_firestore_v1_Value> optional_value;
     if (_limit) {
-      optional_value.emplace(
-          std::make_pair(std::string("limit"),
-                         nanopb::SharedMessage<firebase::firestore::google_firestore_v1_Value>(
-                             [reader parsedQueryValue:_limit])));
+      optional_value.emplace(std::make_pair(
+          std::string("limit"), *DeepClone(*[reader parsedQueryValue:_limit]).release()));
     }
 
     if (_distanceField) {
+      std::shared_ptr<Expr> cpp_distance_field = [_distanceField cppExprWithReader:reader];
       optional_value.emplace(
-          std::make_pair(std::string("distance_field"),
-                         nanopb::SharedMessage<firebase::firestore::google_firestore_v1_Value>(
-                             [reader parsedQueryValue:_distanceField])));
+          std::make_pair(std::string("distance_field"), cpp_distance_field->to_proto()));
     }
 
     FindNearestStage::DistanceMeasure::Measure measure_enum;

Firestore/Source/Public/FirebaseFirestore/FIRPipelineBridge.h

@@ -23,6 +23,7 @@
 @class FIRTimestamp;
 @class FIRVectorValue;
 @class FIRPipelineBridge;
+@class FIRFieldPath;
 
 NS_ASSUME_NONNULL_BEGIN
 
@@ -34,7 +35,9 @@ NS_SWIFT_NAME(ExprBridge)
 NS_SWIFT_SENDABLE
 NS_SWIFT_NAME(FieldBridge)
 @interface FIRFieldBridge : FIRExprBridge
-- (id)init:(NSString *)name;
+- (id)initWithName:(NSString *)name;
+- (id)initWithPath:(FIRFieldPath *)path;
+- (NSString *)field_name;
 @end
 
 NS_SWIFT_SENDABLE
@@ -160,7 +163,7 @@ NS_SWIFT_NAME(FindNearestStageBridge)
         vectorValue:(FIRVectorValue *)vectorValue
     distanceMeasure:(NSString *)distanceMeasure
               limit:(NSNumber *_Nullable)limit
-      distanceField:(NSString *_Nullable)distanceField;
+      distanceField:(FIRExprBridge *_Nullable)distanceField;
 @end
 
 NS_SWIFT_SENDABLE

Firestore/Swift/Source/ExprImpl.swift

@@ -13,7 +13,7 @@
 // limitations under the License.
 
 extension Expr {
   func toBridge() -> ExprBridge {
     return (self as! BridgeWrapper).bridge
   }
 }
@@ -25,14 +25,12 @@
 
   // MARK: Arithmetic Operators
 
-  func add(_ second: Expr, _ others: Expr...) -> FunctionExpr {
-    return FunctionExpr("add", [self, second] + others)
+  func add(_ value: Expr) -> FunctionExpr {
+    return FunctionExpr("add", [self, value])
   }
 
-  func add(_ second: Sendable, _ others: Sendable...) -> FunctionExpr {
-    let exprs = [self] + [Helper.sendableToExpr(second)] + others
-      .map { Helper.sendableToExpr($0) }
-    return FunctionExpr("add", exprs)
+  func add(_ value: Sendable) -> FunctionExpr {
+    return FunctionExpr("add", [self, Helper.sendableToExpr(value)])
   }
 
   func subtract(_ other: Expr) -> FunctionExpr {
@@ -43,14 +41,12 @@
     return FunctionExpr("subtract", [self, Helper.sendableToExpr(other)])
   }
 
-  func multiply(_ second: Expr, _ others: Expr...) -> FunctionExpr {
-    return FunctionExpr("multiply", [self, second] + others)
+  func multiply(_ value: Expr) -> FunctionExpr {
+    return FunctionExpr("multiply", [self, value])
   }
 
-  func multiply(_ second: Sendable, _ others: Sendable...) -> FunctionExpr {
-    let exprs = [self] + [Helper.sendableToExpr(second)] + others
-      .map { Helper.sendableToExpr($0) }
-    return FunctionExpr("multiply", exprs)
+  func multiply(_ value: Sendable) -> FunctionExpr {
+    return FunctionExpr("multiply", [self, Helper.sendableToExpr(value)])
   }
 
   func divide(_ other: Expr) -> FunctionExpr {
@@ -89,34 +85,32 @@
     return BooleanExpr("array_contains", [self, Helper.sendableToExpr(element)])
   }
 
-  func arrayContainsAll(_ values: Expr...) -> BooleanExpr {
-    return BooleanExpr("array_contains_all", [self] + values)
+  func arrayContainsAll(_ values: [Expr]) -> BooleanExpr {
+    return BooleanExpr("array_contains_all", [self, Helper.array(values)])
   }
 
-  func arrayContainsAll(_ values: Sendable...) -> BooleanExpr {
-    let exprValues = values.map { Helper.sendableToExpr($0) }
-    return BooleanExpr("array_contains_all", [self] + exprValues)
+  func arrayContainsAll(_ values: [Sendable]) -> BooleanExpr {
+    return BooleanExpr("array_contains_all", [self, Helper.array(values)])
   }
 
-  func arrayContainsAny(_ values: Expr...) -> BooleanExpr {
-    return BooleanExpr("array_contains_any", [self] + values)
+  func arrayContainsAny(_ values: [Expr]) -> BooleanExpr {
+    return BooleanExpr("array_contains_any", [self, Helper.array(values)])
   }
 
-  func arrayContainsAny(_ values: Sendable...) -> BooleanExpr {
-    let exprValues = values.map { Helper.sendableToExpr($0) }
-    return BooleanExpr("array_contains_any", [self] + exprValues)
+  func arrayContainsAny(_ values: [Sendable]) -> BooleanExpr {
+    return BooleanExpr("array_contains_any", [self, Helper.array(values)])
   }
 
   func arrayLength() -> FunctionExpr {
     return FunctionExpr("array_length", [self])
   }
 
-  func arrayOffset(_ offset: Int) -> FunctionExpr {
-    return FunctionExpr("array_offset", [self, Helper.sendableToExpr(offset)])
+  func arrayGet(_ offset: Int) -> FunctionExpr {
+    return FunctionExpr("array_get", [self, Helper.sendableToExpr(offset)])
   }
 
-  func arrayOffset(_ offsetExpr: Expr) -> FunctionExpr {
-    return FunctionExpr("array_offset", [self, offsetExpr])
+  func arrayGet(_ offsetExpr: Expr) -> FunctionExpr {
+    return FunctionExpr("array_get", [self, offsetExpr])
   }
 
   func gt(_ other: Expr) -> BooleanExpr {
@@ -172,31 +166,28 @@
     return BooleanExpr("eq", [self, exprOther])
   }
 
-  func neq(_ others: Expr...) -> BooleanExpr {
-    return BooleanExpr("neq", [self] + others)
+  func neq(_ other: Expr) -> BooleanExpr {
+    return BooleanExpr("neq", [self, other])
   }
 
-  func neq(_ others: Sendable...) -> BooleanExpr {
-    let exprOthers = others.map { Helper.sendableToExpr($0) }
-    return BooleanExpr("neq", [self] + exprOthers)
+  func neq(_ other: Sendable) -> BooleanExpr {
+    return BooleanExpr("neq", [self, Helper.sendableToExpr(other)])
   }
 
-  func eqAny(_ others: Expr...) -> BooleanExpr {
-    return BooleanExpr("eq_any", [self] + others)
+  func eqAny(_ others: [Expr]) -> BooleanExpr {
+    return BooleanExpr("eq_any", [self, Helper.array(others)])
   }
 
-  func eqAny(_ others: Sendable...) -> BooleanExpr {
-    let exprOthers = others.map { Helper.sendableToExpr($0) }
-    return BooleanExpr("eq_any", [self] + exprOthers)
+  func eqAny(_ others: [Sendable]) -> BooleanExpr {
+    return BooleanExpr("eq_any", [self, Helper.array(others)])
   }
 
-  func notEqAny(_ others: Expr...) -> BooleanExpr {
-    return BooleanExpr("not_eq_any", [self] + others)
+  func notEqAny(_ others: [Expr]) -> BooleanExpr {
+    return BooleanExpr("not_eq_any", [self, Helper.array(others)])
   }
 
-  func notEqAny(_ others: Sendable...) -> BooleanExpr {
-    let exprOthers = others.map { Helper.sendableToExpr($0) }
-    return BooleanExpr("not_eq_any", [self] + exprOthers)
+  func notEqAny(_ others: [Sendable]) -> BooleanExpr {
+    return BooleanExpr("not_eq_any", [self, Helper.array(others)])
   }
 
   // MARK: Checks
@@ -237,12 +228,12 @@
     return FunctionExpr("char_length", [self])
   }
 
-  func like(_ pattern: String) -> FunctionExpr {
-    return FunctionExpr("like", [self, Helper.sendableToExpr(pattern)])
+  func like(_ pattern: String) -> BooleanExpr {
+    return BooleanExpr("like", [self, Helper.sendableToExpr(pattern)])
   }
 
-  func like(_ pattern: Expr) -> FunctionExpr {
-    return FunctionExpr("like", [self, pattern])
+  func like(_ pattern: Expr) -> BooleanExpr {
+    return BooleanExpr("like", [self, pattern])
   }
 
   func regexContains(_ pattern: String) -> BooleanExpr {
@@ -414,13 +405,13 @@
   }
 
   func logicalMinimum(_ second: Expr, _ others: Expr...) -> FunctionExpr {
-    return FunctionExpr("logical_min", [self, second] + others)
+    return FunctionExpr("logical_minimum", [self, second] + others)
   }
 
   func logicalMinimum(_ second: Sendable, _ others: Sendable...) -> FunctionExpr {
     let exprs = [self] + [Helper.sendableToExpr(second)] + others
       .map { Helper.sendableToExpr($0) }
-    return FunctionExpr("logical_min", exprs)
+    return FunctionExpr("logical_minimum", exprs)
   }
 
   // MARK: Vector Operations

Firestore/Swift/Source/Helper/PipelineHelper.swift

@@ -18,20 +18,24 @@ enum Helper {
       return Constant.nil
     }
 
-    if value is Expr {
-      return value as! Expr
-    } else if value is [String: Sendable?] {
-      return map(value as! [String: Sendable?])
-    } else if value is [Sendable?] {
-      return array(value as! [Sendable?])
+    if let exprValue = value as? Expr {
+      return exprValue
+    } else if let dictionaryValue = value as? [String: Sendable?] {
+      return map(dictionaryValue)
+    } else if let arrayValue = value as? [Sendable?] {
+      return array(arrayValue)
+    } else if let timeUnitValue = value as? TimeUnit {
+      return Constant(timeUnitValue.rawValue)
     } else {
       return Constant(value)
     }
   }
 
   static func selectablesToMap(selectables: [Selectable]) -> [String: Expr] {
     let exprMap = selectables.reduce(into: [String: Expr]()) { result, selectable in
-      let value = selectable as! SelectableWrapper
+      guard let value = selectable as? SelectableWrapper else {
+        fatalError("Selectable class must conform to SelectableWrapper.")
+      }
       result[value.alias] = value.expr
     }
     return exprMap
@@ -55,22 +59,18 @@ enum Helper {
 
   // This function is used to convert Swift type into Objective-C type.
   static func sendableToAnyObjectForRawStage(_ value: Sendable?) -> AnyObject {
-    guard let value = value else {
-      return Constant.nil.bridge
-    }
-
-    guard !(value is NSNull) else {
+    guard let value = value, !(value is NSNull) else {
       return Constant.nil.bridge
     }
 
-    if value is Expr {
-      return (value as! Expr).toBridge()
-    } else if value is AggregateFunction {
-      return (value as! AggregateFunction).toBridge()
-    } else if value is [String: Sendable?] {
-      let mappedValue: [String: Sendable?] = (value as! [String: Sendable?]).mapValues {
-        if $0 is AggregateFunction {
-          return ($0 as! AggregateFunction).toBridge()
+    if let exprValue = value as? Expr {
+      return exprValue.toBridge()
+    } else if let aggregateFunctionValue = value as? AggregateFunction {
+      return aggregateFunctionValue.toBridge()
+    } else if let dictionaryValue = value as? [String: Sendable?] {
+      let mappedValue: [String: Sendable] = dictionaryValue.mapValues {
+        if let aggFunc = $0 as? AggregateFunction {
+          return aggFunc.toBridge()
         }
         return sendableToExpr($0).toBridge()
       }
@@ -79,4 +79,14 @@ enum Helper {
       return Constant(value).bridge
     }
   }
+
+  static func convertObjCToSwift(_ objValue: Sendable) -> Sendable? {
+    switch objValue {
+    case is NSNull:
+      return nil
+
+    default:
+      return objValue
+    }
+  }
 }