replace varadic list with array and add tests

Author: cherylEnkidu

Firestore/Swift/Source/ExprImpl.swift

@@ -89,22 +89,20 @@ public extension Expr {
     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 {
@@ -172,31 +170,28 @@ public extension Expr {
     return BooleanExpr("eq", [self, exprOther])
   }
 
-  func neq(_ others: Expr...) -> BooleanExpr {
-    return BooleanExpr("neq", [self] + others)
+  func neq(_ others: [Expr]) -> BooleanExpr {
+    return BooleanExpr("neq", [self, Helper.array(others)])
   }
 
-  func neq(_ others: Sendable...) -> BooleanExpr {
-    let exprOthers = others.map { Helper.sendableToExpr($0) }
-    return BooleanExpr("neq", [self] + exprOthers)
+  func neq(_ others: [Sendable]) -> BooleanExpr {
+    return BooleanExpr("neq", [self, Helper.array(others)])
   }
 
-  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 +232,12 @@ public extension Expr {
     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 +409,13 @@ public extension Expr {
   }
 
   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/SwiftAPI/Pipeline/Expr.swift

@@ -239,55 +239,55 @@ public protocol Expr: Sendable {
   /// ```swift
   /// // Check if 'candidateSkills' contains all skills from 'requiredSkill1' and 'requiredSkill2'
   /// fields
-  /// Field("candidateSkills").arrayContainsAll(Field("requiredSkill1"), Field("requiredSkill2"))
+  /// Field("candidateSkills").arrayContainsAll([Field("requiredSkill1"), Field("requiredSkill2")])
   /// ```
   ///
-  /// - Parameter values: A variadic list of `Expr` elements to check for in the array represented
+  /// - Parameter values: A list of `Expr` elements to check for in the array represented
   /// by `self`.
   /// - Returns: A new `BooleanExpr` representing the 'array_contains_all' comparison.
-  func arrayContainsAll(_ values: Expr...) -> BooleanExpr
+  func arrayContainsAll(_ values: [Expr]) -> BooleanExpr
 
   /// Creates an expression that checks if an array (from `self`) contains all the specified literal
   /// elements.
   /// Assumes `self` evaluates to an array.
   ///
   /// ```swift
   /// // Check if 'tags' contains both "urgent" and "review"
-  /// Field("tags").arrayContainsAll("urgent", "review")
+  /// Field("tags").arrayContainsAll(["urgent", "review"])
   /// ```
   ///
-  /// - Parameter values: A variadic list of `Sendable` literal elements to check for in the array
+  /// - Parameter values: A list of `Sendable` literal elements to check for in the array
   /// represented by `self`.
   /// - Returns: A new `BooleanExpr` representing the 'array_contains_all' comparison.
-  func arrayContainsAll(_ values: Sendable...) -> BooleanExpr
+  func arrayContainsAll(_ values: [Sendable]) -> BooleanExpr
 
   /// Creates an expression that checks if an array (from `self`) contains any of the specified
   /// element expressions.
   /// Assumes `self` evaluates to an array.
   ///
   /// ```swift
   /// // Check if 'userGroups' contains any group from 'allowedGroup1' or 'allowedGroup2' fields
-  /// Field("userGroups").arrayContainsAny(Field("allowedGroup1"), Field("allowedGroup2"))
+  /// Field("userGroups").arrayContainsAny([Field("allowedGroup1"), Field("allowedGroup2")])
   /// ```
   ///
-  /// - Parameter values: A variadic list of `Expr` elements to check for in the array represented
+  /// - Parameter values: A list of `Expr` elements to check for in the array represented
   /// by `self`.
   /// - Returns: A new `BooleanExpr` representing the 'array_contains_any' comparison.
-  func arrayContainsAny(_ values: Expr...) -> BooleanExpr
+  func arrayContainsAny(_ values: [Expr]) -> BooleanExpr
 
   /// Creates an expression that checks if an array (from `self`) contains any of the specified
   /// literal elements.
   /// Assumes `self` evaluates to an array.
   ///
   /// ```swift
   /// // Check if 'categories' contains either "electronics" or "books"
-  /// Field("categories").arrayContainsAny("electronics", "books")
+  /// Field("categories").arrayContainsAny(["electronics", "books"])
   /// ```
   ///
-  /// - Parameter values: A variadic list of `Sendable` literal elements to check for in the array
+  /// - Parameter values: A list of `Sendable` literal elements to check for in the array
   /// represented by `self`.
   /// - Returns: A new `BooleanExpr` representing the 'array_contains_any' comparison.
-  func arrayContainsAny(_ values: Sendable...) -> BooleanExpr
+  func arrayContainsAny(_ values: [Sendable]) -> BooleanExpr
 
   /// Creates an expression that calculates the length of an array.
   /// Assumes `self` evaluates to an array.
@@ -341,51 +341,51 @@ public protocol Expr: Sendable {
   ///
   /// ```swift
   /// // Check if 'categoryID' field is equal to 'featuredCategory' or 'popularCategory' fields
-  /// Field("categoryID").eqAny(Field("featuredCategory"), Field("popularCategory"))
+  /// Field("categoryID").eqAny([Field("featuredCategory"), Field("popularCategory")])
   /// ```
   ///
-  /// - Parameter others: A variadic list of `Expr` values to check against.
+  /// - Parameter others: A list of `Expr` values to check against.
   /// - Returns: A new `BooleanExpr` representing the 'IN' comparison (eq_any).
-  func eqAny(_ others: Expr...) -> BooleanExpr
+  func eqAny(_ others: [Expr]) -> BooleanExpr
 
   /// Creates an expression that checks if this expression is equal to any of the provided literal
   /// values.
   /// This is similar to an "IN" operator in SQL.
   ///
   /// ```swift
   /// // Check if 'category' is "Electronics", "Books", or "Home Goods"
-  /// Field("category").eqAny("Electronics", "Books", "Home Goods")
+  /// Field("category").eqAny(["Electronics", "Books", "Home Goods"])
   /// ```
   ///
-  /// - Parameter others: A variadic list of `Sendable` literal values to check against.
+  /// - Parameter others: A list of `Sendable` literal values to check against.
   /// - Returns: A new `BooleanExpr` representing the 'IN' comparison (eq_any).
-  func eqAny(_ others: Sendable...) -> BooleanExpr
+  func eqAny(_ others: [Sendable]) -> BooleanExpr
 
   /// Creates an expression that checks if this expression is not equal to any of the provided
   /// expression values.
   /// This is similar to a "NOT IN" operator in SQL.
   ///
   /// ```swift
   /// // Check if 'statusValue' is not equal to 'archivedStatus' or 'deletedStatus' fields
-  /// Field("statusValue").notEqAny(Field("archivedStatus"), Field("deletedStatus"))
+  /// Field("statusValue").notEqAny([Field("archivedStatus"), Field("deletedStatus")])
   /// ```
   ///
-  /// - Parameter others: A variadic list of `Expr` values to check against.
+  /// - Parameter others: A list of `Expr` values to check against.
   /// - Returns: A new `BooleanExpr` representing the 'NOT IN' comparison (not_eq_any).
-  func notEqAny(_ others: Expr...) -> BooleanExpr
+  func notEqAny(_ others: [Expr]) -> BooleanExpr
 
   /// Creates an expression that checks if this expression is not equal to any of the provided
   /// literal values.
   /// This is similar to a "NOT IN" operator in SQL.
   ///
   /// ```swift
   /// // Check if 'status' is neither "pending" nor "archived"
-  /// Field("status").notEqAny("pending", "archived")
+  /// Field("status").notEqAny(["pending", "archived"])
   /// ```
   ///
-  /// - Parameter others: A variadic list of `Sendable` literal values to check against.
+  /// - Parameter others: A list of `Sendable` literal values to check against.
   /// - Returns: A new `BooleanExpr` representing the 'NOT IN' comparison (not_eq_any).
-  func notEqAny(_ others: Sendable...) -> BooleanExpr
+  func notEqAny(_ others: [Sendable]) -> BooleanExpr
 
   // MARK: Checks
 
@@ -495,7 +495,7 @@ public protocol Expr: Sendable {
   ///
   /// - Parameter pattern: The literal string pattern to search for. Use "%" as a wildcard.
   /// - Returns: A new `FunctionExpr` representing the 'like' comparison.
-  func like(_ pattern: String) -> FunctionExpr
+  func like(_ pattern: String) -> BooleanExpr
 
   /// Creates an expression that performs a case-sensitive string comparison using wildcards against
   /// an expression pattern.
@@ -509,7 +509,7 @@ public protocol Expr: Sendable {
   /// - Parameter pattern: An `Expr` (evaluating to a string) representing the pattern to search
   /// for.
   /// - Returns: A new `FunctionExpr` representing the 'like' comparison.
-  func like(_ pattern: Expr) -> FunctionExpr
+  func like(_ pattern: Expr) -> BooleanExpr
 
   /// Creates an expression that checks if a string (from `self`) contains a specified regular
   /// expression literal as a substring.

Firestore/Swift/Source/SwiftAPI/Pipeline/Expr/FunctionExpr/BooleanExpr.swift

@@ -21,6 +21,10 @@ public class BooleanExpr: FunctionExpr, @unchecked Sendable {
     return AggregateFunction("count_if", [self])
   }
 
+  public func then(_ thenExpr: Expr, else elseExpr: Expr) -> FunctionExpr {
+    return FunctionExpr("cond", [self, thenExpr, elseExpr])
+  }
+
   public static func && (lhs: BooleanExpr,
                          rhs: @autoclosure () throws -> BooleanExpr) rethrows -> BooleanExpr {
     try BooleanExpr("and", [lhs, rhs()])