Add checking for duplicate alias

Firestore/Swift/Source/Helper/PipelineHelper.swift

@@ -13,6 +13,17 @@
 // limitations under the License.
 
 enum Helper {
+  enum HelperError: Error, LocalizedError {
+    case duplicateAlias(String)
+
+    public var errorDescription: String? {
+      switch self {
+      case let .duplicateAlias(message):
+        return message
+      }
+    }
+  }
+
   static func sendableToExpr(_ value: Sendable?) -> Expression {
     guard let value = value else {
       return Constant.nil
@@ -31,14 +42,35 @@ enum Helper {
     }
   }
 
-  static func selectablesToMap(selectables: [Selectable]) -> [String: Expression] {
-    let exprMap = selectables.reduce(into: [String: Expression]()) { result, selectable in
+  static func selectablesToMap(selectables: [Selectable]) -> ([String: Expression], Error?) {
+    var exprMap = [String: Expression]()
+    for selectable in selectables {
       guard let value = selectable as? SelectableWrapper else {
         fatalError("Selectable class must conform to SelectableWrapper.")
       }
-      result[value.alias] = value.expr
+      let alias = value.alias
+      if exprMap.keys.contains(alias) {
+        return ([:], HelperError.duplicateAlias("Duplicate alias '\(alias)' found in selectables."))
+      }
+      exprMap[alias] = value.expr
+    }
+    return (exprMap, nil)
+  }
+
+  static func aliasedAggregatesToMap(accumulators: [AliasedAggregate])
+    -> ([String: AggregateFunction], Error?) {
+    var accumulatorMap = [String: AggregateFunction]()
+    for aliasedAggregate in accumulators {
+      let alias = aliasedAggregate.alias
+      if accumulatorMap.keys.contains(alias) {
+        return (
+          [:],
+          HelperError.duplicateAlias("Duplicate alias '\(alias)' found in accumulators.")
+        )
+      }
+      accumulatorMap[alias] = aliasedAggregate.aggregate
     }
-    return exprMap
+    return (accumulatorMap, nil)
   }
 
   static func map(_ elements: [String: Sendable?]) -> FunctionExpression {
@@ -66,11 +98,11 @@ enum Helper {
     if let exprValue = value as? Expression {
       return exprValue.toBridge()
     } else if let aggregateFunctionValue = value as? AggregateFunction {
-      return aggregateFunctionValue.toBridge()
+      return aggregateFunctionValue.bridge
     } else if let dictionaryValue = value as? [String: Sendable?] {
       let mappedValue: [String: Sendable] = dictionaryValue.mapValues {
         if let aggFunc = $0 as? AggregateFunction {
-          return aggFunc.toBridge()
+          return aggFunc.bridge
         }
         return sendableToExpr($0).toBridge()
       }

Firestore/Swift/Source/Stages.swift

@@ -26,6 +26,13 @@ import Foundation
 protocol Stage {
   var name: String { get }
   var bridge: StageBridge { get }
+  var errorMessage: String? { get }
+}
+
+extension Stage {
+  var errorMessage: String? {
+    return nil
+  }
 }
 
 @available(iOS 13, tvOS 13, macOS 10.15, macCatalyst 13, watchOS 7, *)
@@ -147,17 +154,19 @@ class AddFields: Stage {
   let name: String = "add_fields"
   let bridge: StageBridge
   private var selectables: [Selectable]
+  let errorMessage: String?
 
   init(selectables: [Selectable]) {
     self.selectables = selectables
-    let objc_accumulators = selectables.reduce(into: [String: ExprBridge]()) {
-      result,
-        selectable
-      in
-      let selectableWrapper = selectable as! SelectableWrapper
-      result[selectableWrapper.alias] = selectableWrapper.expr.toBridge()
+    let (map, error) = Helper.selectablesToMap(selectables: selectables)
+    if let error = error {
+      errorMessage = error.localizedDescription
+      bridge = AddFieldsStageBridge(fields: [:])
+    } else {
+      errorMessage = nil
+      let objcAccumulators = map.mapValues { $0.toBridge() }
+      bridge = AddFieldsStageBridge(fields: objcAccumulators)
     }
-    bridge = AddFieldsStageBridge(fields: objc_accumulators)
   }
 }
 
@@ -182,23 +191,37 @@ class RemoveFieldsStage: Stage {
 class Select: Stage {
   let name: String = "select"
   let bridge: StageBridge
+  let errorMessage: String?
 
   init(selections: [Selectable]) {
-    let map = Helper.selectablesToMap(selectables: selections)
-    bridge = SelectStageBridge(selections: map
-      .mapValues { Helper.sendableToExpr($0).toBridge() })
+    let (map, error) = Helper.selectablesToMap(selectables: selections)
+    if let error = error {
+      errorMessage = error.localizedDescription
+      bridge = SelectStageBridge(selections: [:])
+    } else {
+      errorMessage = nil
+      let objcSelections = map.mapValues { Helper.sendableToExpr($0).toBridge() }
+      bridge = SelectStageBridge(selections: objcSelections)
+    }
   }
 }
 
 @available(iOS 13, tvOS 13, macOS 10.15, macCatalyst 13, watchOS 7, *)
 class Distinct: Stage {
   let name: String = "distinct"
   let bridge: StageBridge
+  let errorMessage: String?
 
   init(groups: [Selectable]) {
-    let map = Helper.selectablesToMap(selectables: groups)
-    bridge = DistinctStageBridge(groups: map
-      .mapValues { Helper.sendableToExpr($0).toBridge() })
+    let (map, error) = Helper.selectablesToMap(selectables: groups)
+    if let error = error {
+      errorMessage = error.localizedDescription
+      bridge = DistinctStageBridge(groups: [:])
+    } else {
+      errorMessage = nil
+      let objcGroups = map.mapValues { Helper.sendableToExpr($0).toBridge() }
+      bridge = DistinctStageBridge(groups: objcGroups)
+    }
   }
 }
 
@@ -208,18 +231,32 @@ class Aggregate: Stage {
   let bridge: StageBridge
   private var accumulators: [AliasedAggregate]
   private var groups: [String: Expression] = [:]
+  let errorMessage: String?
 
   init(accumulators: [AliasedAggregate], groups: [Selectable]?) {
     self.accumulators = accumulators
-    if groups != nil {
-      self.groups = Helper.selectablesToMap(selectables: groups!)
-    }
-    let accumulatorsMap = accumulators
-      .reduce(into: [String: AggregateFunctionBridge]()) { result, accumulator in
-        result[accumulator.alias] = accumulator.aggregate.bridge
+
+    if let groups = groups {
+      let (map, error) = Helper.selectablesToMap(selectables: groups)
+      if let error = error {
+        errorMessage = error.localizedDescription
+        bridge = AggregateStageBridge(accumulators: [:], groups: [:])
+        return
       }
+      self.groups = map
+    }
+
+    let (accumulatorsMap, error) = Helper.aliasedAggregatesToMap(accumulators: accumulators)
+    if let error = error {
+      errorMessage = error.localizedDescription
+      bridge = AggregateStageBridge(accumulators: [:], groups: [:])
+      return
+    }
+
+    errorMessage = nil
+    let accumulatorBridgesMap = accumulatorsMap.mapValues { $0.bridge }
     bridge = AggregateStageBridge(
-      accumulators: accumulatorsMap,
+      accumulators: accumulatorBridgesMap,
       groups: self.groups.mapValues { Helper.sendableToExpr($0).toBridge() }
     )
   }

Firestore/Swift/Source/SwiftAPI/Pipeline/Aggregates/AggregateFunction.swift

@@ -12,12 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-extension AggregateFunction {
-  func toBridge() -> AggregateFunctionBridge {
-    return (self as AggregateBridgeWrapper).bridge
-  }
-}
-
 /// Represents an aggregate function in a pipeline.
 ///
 /// An `AggregateFunction` is a function that computes a single value from a set of input values.