expand expr to expression

Author: cherylEnkidu

Firestore/Swift/Source/ExpressionImplementation.swift

@@ -116,8 +116,8 @@ public extension Expression {
     return FunctionExpression("array_get", [self, Helper.sendableToExpr(offset)])
   }
 
-  func arrayGet(_ offsetExpr: Expression) -> FunctionExpression {
-    return FunctionExpression("array_get", [self, offsetExpr])
+  func arrayGet(_ offsetExpression: Expression) -> FunctionExpression {
+    return FunctionExpression("array_get", [self, offsetExpression])
   }
 
   func greaterThan(_ other: Expression) -> BooleanExpression {
@@ -263,8 +263,8 @@ public extension Expression {
     return BooleanExpression("string_contains", [self, Helper.sendableToExpr(substring)])
   }
 
-  func strContains(_ expr: Expression) -> BooleanExpression {
-    return BooleanExpression("string_contains", [self, expr])
+  func string_contains(_ expression: Expression) -> BooleanExpression {
+    return BooleanExpression("string_contains", [self, expression])
   }
 
   func startsWith(_ prefix: String) -> BooleanExpression {
@@ -295,7 +295,7 @@ public extension Expression {
     return FunctionExpression("trim", [self])
   }
 
-  func strConcat(_ strings: [Expression]) -> FunctionExpression {
+  func stringConcat(_ strings: [Expression]) -> FunctionExpression {
     return FunctionExpression("string_concat", [self] + strings)
   }
 
@@ -356,8 +356,8 @@ public extension Expression {
     return FunctionExpression("map_remove", [self, Helper.sendableToExpr(key)])
   }
 
-  func mapRemove(_ keyExpr: Expression) -> FunctionExpression {
-    return FunctionExpression("map_remove", [self, keyExpr])
+  func mapRemove(_ keyExpression: Expression) -> FunctionExpression {
+    return FunctionExpression("map_remove", [self, keyExpression])
   }
 
   func mapMerge(_ maps: [[String: Sendable]]) -> FunctionExpression {
@@ -559,24 +559,24 @@ public extension Expression {
     return FunctionExpression("bit_left_shift", [self, Helper.sendableToExpr(y)])
   }
 
-  func bitLeftShift(_ numberExpr: Expression) -> FunctionExpression {
-    return FunctionExpression("bit_left_shift", [self, numberExpr])
+  func bitLeftShift(_ numberExpression: Expression) -> FunctionExpression {
+    return FunctionExpression("bit_left_shift", [self, numberExpression])
   }
 
   func bitRightShift(_ y: Int) -> FunctionExpression {
     return FunctionExpression("bit_right_shift", [self, Helper.sendableToExpr(y)])
   }
 
-  func bitRightShift(_ numberExpr: Expression) -> FunctionExpression {
-    return FunctionExpression("bit_right_shift", [self, numberExpr])
+  func bitRightShift(_ numberExpression: Expression) -> FunctionExpression {
+    return FunctionExpression("bit_right_shift", [self, numberExpression])
   }
 
   func documentId() -> FunctionExpression {
     return FunctionExpression("document_id", [self])
   }
 
-  func ifError(_ catchExpr: Expression) -> FunctionExpression {
-    return FunctionExpression("if_error", [self, catchExpr])
+  func ifError(_ catchExpression: Expression) -> FunctionExpression {
+    return FunctionExpression("if_error", [self, catchExpression])
   }
 
   func ifError(_ catchValue: Sendable) -> FunctionExpression {
@@ -586,10 +586,10 @@ public extension Expression {
   // MARK: Sorting
 
   func ascending() -> Ordering {
-    return Ordering(expr: self, direction: .ascending)
+    return Ordering(expression: self, direction: .ascending)
   }
 
   func descending() -> Ordering {
-    return Ordering(expr: self, direction: .descending)
+    return Ordering(expression: self, direction: .descending)
   }
 }

Firestore/Swift/Source/SwiftAPI/Pipeline/Expression.swift

@@ -350,7 +350,7 @@ public protocol Expression: Sendable {
   /// - Parameter offsetExpr: An `Expression` (evaluating to an Int) representing the offset of the
   /// element to return.
   /// - Returns: A new `FunctionExpression` representing the "arrayGet" operation.
-  func arrayGet(_ offsetExpr: Expression) -> FunctionExpression
+  func arrayGet(_ offsetExpression: Expression) -> FunctionExpression
 
   /// Creates a `BooleanExpr` that returns `true` if this expression is greater
   /// than the given expression.
@@ -699,7 +699,7 @@ public protocol Expression: Sendable {
   ///
   /// ```swift
   /// // Check if the "description" field contains "example".
-  /// Field("description").strContains("example")
+  /// Field("description").string_contains("example")
   /// ```
   ///
   /// - Parameter substring: The literal string substring to search for.
@@ -712,13 +712,13 @@ public protocol Expression: Sendable {
   ///
   /// ```swift
   /// // Check if the "message" field contains the value of the "keyword" field.
-  /// Field("message").strContains(Field("keyword"))
+  /// Field("message").string_contains(Field("keyword"))
   /// ```
   ///
   /// - Parameter expr: An `Expression` (evaluating to a string) representing the substring to
   /// search for.
   /// - Returns: A new `BooleanExpr` representing the "str_contains" comparison.
-  func strContains(_ expr: Expression) -> BooleanExpression
+  func string_contains(_ expression: Expression) -> BooleanExpression
 
   /// Creates an expression that checks if a string (from `self`) starts with a given literal prefix
   /// (case-sensitive).
@@ -813,14 +813,14 @@ public protocol Expression: Sendable {
   ///
   /// ```swift
   /// // Combine "firstName", "middleName", and "lastName" fields
-  /// Field("firstName").strConcat(Field("middleName"), Field("lastName"))
+  /// Field("firstName").stringConcat(Field("middleName"), Field("lastName"))
   /// ```
   ///
   /// - Parameter secondString: An `Expression` (evaluating to a string) to concatenate.
   /// - Parameter otherStrings: Optional additional `Expression` (evaluating to strings) to
   /// concatenate.
   /// - Returns: A new `FunctionExpression` representing the concatenated string.
-  func strConcat(_ strings: [Expression]) -> FunctionExpression
+  func stringConcat(_ strings: [Expression]) -> FunctionExpression
 
   /// Creates an expression that reverses this string expression.
   /// Assumes `self` evaluates to a string.
@@ -989,7 +989,7 @@ public protocol Expression: Sendable {
   /// - Parameter keyExpr: An `Expr` (evaluating to a string) representing the key to remove from
   /// the map.
   /// - Returns: A new `FunctionExpr` representing the "map_remove" operation.
-  func mapRemove(_ keyExpr: Expression) -> FunctionExpression
+  func mapRemove(_ keyExpression: Expression) -> FunctionExpression
 
   /// Creates an expression that merges this map with multiple other map literals.
   /// Assumes `self` evaluates to a Map. Later maps overwrite keys from earlier maps.
@@ -1584,7 +1584,7 @@ public protocol Expression: Sendable {
   /// ```
   /// - Parameter numberExpr: An `Expr` (evaluating to an Int) for the number of bits to shift by.
   /// - Returns: A new "FunctionExpression" representing the bitwise left shift operation.
-  func bitLeftShift(_ numberExpr: Expression) -> FunctionExpression
+  func bitLeftShift(_ numberExpression: Expression) -> FunctionExpression
 
   /// Creates an expression applying bitwise right shift to this expression by a literal number of
   /// bits.
@@ -1612,7 +1612,7 @@ public protocol Expression: Sendable {
   /// ```
   /// - Parameter numberExpr: An `Expr` (evaluating to an Int) for the number of bits to shift by.
   /// - Returns: A new "FunctionExpression" representing the bitwise right shift operation.
-  func bitRightShift(_ numberExpr: Expression) -> FunctionExpression
+  func bitRightShift(_ numberExpression: Expression) -> FunctionExpression
 
   func documentId() -> FunctionExpression
 

Firestore/Swift/Source/SwiftAPI/Pipeline/Expressions/FunctionExpressions/BooleanExpression.swift

@@ -52,7 +52,7 @@ public class BooleanExpression: FunctionExpression, @unchecked Sendable {
   /// ```
   ///
   /// - Returns: An `AggregateFunction` that performs the conditional count.
-  public func countIf() -> AggregateFunction {
+  internal func countIf() -> AggregateFunction {
     return AggregateFunction("count_if", [self])
   }
 

Firestore/Swift/Source/SwiftAPI/Pipeline/Expressions/FunctionExpressions/ConditionalExpression.swift

@@ -0,0 +1,49 @@
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import Foundation
+
+///
+/// A `ConditionalExpression` is a `FunctionExpression` that evaluates to one of two expressions
+/// based on a boolean condition.
+///
+/// This is equivalent to a ternary operator (`condition ? then : else`).
+///
+/// Example of using `ConditionalExpression`:
+/// ```swift
+/// // Create a new field "status" based on the "rating" field.
+/// // If rating > 4.5, status is "top_rated", otherwise "regular".
+/// firestore.pipeline()
+///   .collection("products")
+///   .addFields([
+///     ConditionalExpression(
+///       Field("rating").greaterThan(4.5),
+///       then: Constant("top_rated"),
+///       else: Constant("regular")
+///     ).as("status")
+///   ])
+/// ```
+public class ConditionalExpression: FunctionExpression, @unchecked Sendable {
+  /// Creates a new `ConditionalExpression`.
+  ///
+  /// - Parameters:
+  ///   - expr: The `BooleanExpression` to evaluate.
+  ///   - thenExpression: The `Expression` to evaluate if the boolean expression is `true`.
+  ///   - elseExpression: The `Expression` to evaluate if the boolean expression is `false`.
+  public init(_ expr: BooleanExpression,
+              then thenExpression: Expression,
+              else elseExpression: Expression) {
+    super.init("conditional", [expr, thenExpression, elseExpression])
+  }
+}

Firestore/Swift/Source/SwiftAPI/Pipeline/Ordering.swift

@@ -19,10 +19,10 @@ public struct Ordering: @unchecked Sendable {
   let direction: Direction
   let bridge: OrderingBridge
 
-  init(expr: Expression, direction: Direction) {
-    self.expr = expr
+  init(expression: Expression, direction: Direction) {
+    self.expr = expression
     self.direction = direction
-    bridge = OrderingBridge(expr: expr.toBridge(), direction: direction.rawValue)
+    bridge = OrderingBridge(expr: expression.toBridge(), direction: direction.rawValue)
   }
 }
 

Firestore/Swift/Tests/Integration/PipelineTests.swift

@@ -823,27 +823,28 @@ class PipelineIntegrationTests: FSTIntegrationTestCase {
       XCTFail("No result for min/max/count/countAll aggregation")
     }
   }
-
-  func testReturnsCountIfAccumulation() async throws {
-    let collRef = collectionRef(withDocuments: bookDocs)
-    let db = collRef.firestore
-
-    let expectedCount = 3
-    let expectedResults: [String: Sendable] = ["count": expectedCount]
-    let condition = Field("rating").greaterThan(4.3)
-
-    let pipeline = db.pipeline()
-      .collection(collRef.path)
-      .aggregate([condition.countIf().as("count")])
-    let snapshot = try await pipeline.execute()
-
-    XCTAssertEqual(snapshot.results.count, 1, "countIf aggregate should return a single document")
-    if let result = snapshot.results.first {
-      TestHelper.compare(pipelineResult: result, expected: expectedResults)
-    } else {
-      XCTFail("No result for countIf aggregation")
-    }
-  }
+  
+// Hide this test due to `.countIf()` design is incomplete.
+//  func testReturnsCountIfAccumulation() async throws {
+//    let collRef = collectionRef(withDocuments: bookDocs)
+//    let db = collRef.firestore
+//
+//    let expectedCount = 3
+//    let expectedResults: [String: Sendable] = ["count": expectedCount]
+//    let condition = Field("rating").greaterThan(4.3)
+//
+//    let pipeline = db.pipeline()
+//      .collection(collRef.path)
+//      .aggregate([condition.countIf().as("count")])
+//    let snapshot = try await pipeline.execute()
+//
+//    XCTAssertEqual(snapshot.results.count, 1, "countIf aggregate should return a single document")
+//    if let result = snapshot.results.first {
+//      TestHelper.compare(pipelineResult: result, expected: expectedResults)
+//    } else {
+//      XCTFail("No result for countIf aggregation")
+//    }
+//  }
 
   func testDistinctStage() async throws {
     let collRef = collectionRef(withDocuments: bookDocs)
@@ -1130,7 +1131,7 @@ class PipelineIntegrationTests: FSTIntegrationTestCase {
         name: "add_fields",
         params: [
           [
-            "display": Field("title").strConcat([
+            "display": Field("title").stringConcat([
               Constant(" - "),
               Field("author"),
             ]),
@@ -1767,7 +1768,7 @@ class PipelineIntegrationTests: FSTIntegrationTestCase {
     let pipeline = db.pipeline()
       .collection(collRef.path)
       .sort([Field("author").ascending()])
-      .select([Field("author").strConcat([Constant(" - "), Field("title")]).as("bookInfo")])
+      .select([Field("author").stringConcat([Constant(" - "), Field("title")]).as("bookInfo")])
       .limit(1)
 
     let snapshot = try await pipeline.execute()