make duplicate alias recoverable error

Author: cherylEnkidu

Firestore/Swift/Source/Helper/PipelineHelper.swift

@@ -13,6 +13,11 @@
 // limitations under the License.
 
 enum Helper {
+  
+  enum HelperError: Error {
+    case duplicateAlias(String)
+  }
+  
   static func sendableToExpr(_ value: Sendable?) -> Expression {
     guard let value = value else {
       return Constant.nil
@@ -31,34 +36,32 @@ enum Helper {
     }
   }
 
-  static func selectablesToMap(selectables: [Selectable]) -> [String: Expression] {
-    let exprMap = selectables.reduce(into: [String: Expression]()) { result, selectable in
-      guard let value = selectable as? SelectableWrapper else {
-        fatalError("Selectable class must conform to SelectableWrapper.")
-      }
-      let alias = value.alias
-      if result.keys.contains(alias) {
-        // TODO: Add tests to verify the behaviour.
-        fatalError("Duplicate alias '\(alias)' found in selectables.")
-      }
-      result[alias] = value.expr
+  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.")
+        }
+        let alias = value.alias
+        if exprMap.keys.contains(alias) {
+            return ([:], HelperError.duplicateAlias("Duplicate alias '\(alias)' found in selectables."))
+        }
+        exprMap[alias] = value.expr
     }
-    return exprMap
+    return (exprMap, nil)
   }
 
   static func aliasedAggregatesToMap(accumulators: [AliasedAggregate])
-    -> [String: AggregateFunction] {
-    let accumulatorMap = accumulators
-      .reduce(into: [String: AggregateFunction]()) { result, aliasedAggregate in
-
+    -> ([String: AggregateFunction], Error?) {
+    var accumulatorMap = [String: AggregateFunction]()
+    for aliasedAggregate in accumulators {
         let alias = aliasedAggregate.alias
-        if result.keys.contains(alias) {
-          // TODO: Add tests to verify the behaviour.
-          fatalError("Duplicate alias '\(alias)' found in accumulators.")
+        if accumulatorMap.keys.contains(alias) {
+            return ([:], HelperError.duplicateAlias("Duplicate alias '\(alias)' found in accumulators."))
         }
-        result[alias] = aliasedAggregate.aggregate
-      }
-    return accumulatorMap
+        accumulatorMap[alias] = aliasedAggregate.aggregate
+    }
+    return (accumulatorMap, nil)
   }
 
   static func map(_ elements: [String: Sendable?]) -> FunctionExpression {

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,12 +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 map = Helper.selectablesToMap(selectables: selectables)
-    let objcAccumulators = map.mapValues { $0.toBridge() }
-    bridge = AddFieldsStageBridge(fields: objcAccumulators)
+    let (map, error) = Helper.selectablesToMap(selectables: selectables)
+    if let error = error {
+        self.errorMessage = error.localizedDescription
+        self.bridge = AddFieldsStageBridge(fields: [:])
+    } else {
+        self.errorMessage = nil
+        let objcAccumulators = map.mapValues { $0.toBridge() }
+        self.bridge = AddFieldsStageBridge(fields: objcAccumulators)
+    }
   }
 }
 
@@ -177,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 {
+        self.errorMessage = error.localizedDescription
+        self.bridge = SelectStageBridge(selections: [:])
+    } else {
+        self.errorMessage = nil
+        let objcSelections = map.mapValues { Helper.sendableToExpr($0).toBridge() }
+        self.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 {
+        self.errorMessage = error.localizedDescription
+        self.bridge = DistinctStageBridge(groups: [:])
+    } else {
+        self.errorMessage = nil
+        let objcGroups = map.mapValues { Helper.sendableToExpr($0).toBridge() }
+        self.bridge = DistinctStageBridge(groups: objcGroups)
+    }
   }
 }
 
@@ -203,16 +231,30 @@ 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!)
+
+    if let groups = groups {
+        let (map, error) = Helper.selectablesToMap(selectables: groups)
+        if let error = error {
+            self.errorMessage = error.localizedDescription
+            self.bridge = AggregateStageBridge(accumulators: [:], groups: [:])
+            return
+        }
+        self.groups = map
     }
-    let accumulatorsMap = Helper.aliasedAggregatesToMap(accumulators: accumulators)
 
+    let (accumulatorsMap, error) = Helper.aliasedAggregatesToMap(accumulators: accumulators)
+    if let error = error {
+        self.errorMessage = error.localizedDescription
+        self.bridge = AggregateStageBridge(accumulators: [:], groups: [:])
+        return
+    }
+    
+    self.errorMessage = nil
     let accumulatorBridgesMap = accumulatorsMap.mapValues { $0.bridge }
-
     bridge = AggregateStageBridge(
       accumulators: accumulatorBridgesMap,
       groups: self.groups.mapValues { Helper.sendableToExpr($0).toBridge() }