Check type name conflicts in SelectionSet

Sources/ApolloCodegenLib/ApolloCodegen.swift

@@ -21,6 +21,7 @@ public class ApolloCodegen {
     case invalidConfiguration(message: String)
     case invalidSchemaName(_ name: String, message: String)
     case targetNameConflict(name: String)
+    case typeNameConflict(name: String, conflictingName: String)
 
     public var errorDescription: String? {
       switch self {
@@ -53,8 +54,13 @@ public class ApolloCodegen {
         return "The schema namespace `\(name)` is invalid: \(message)"
       case let .targetNameConflict(name):
         return """
-          Target name '\(name)' conflicts with a reserved library name. Please choose a different \
-          target name.
+        Target name '\(name)' conflicts with a reserved library name. Please choose a different \
+        target name.
+        """
+      case let .typeNameConflict(name, conflictingName):
+        return """
+        Field '\(conflictingName)' conflicts with field '\(name)' in selection set. Recommend \
+        using a field alias for one of these fields to resolve this conflict.
         """
       }
     }
@@ -212,6 +218,24 @@ public class ApolloCodegen {
       throw Error.schemaNameConflict(name: context.schemaNamespace)
     }
   }
+
+  /// Validates that there are no type conflicts within a SelectionSet
+  static private func validateTypeConflicts(for selectionSet: IR.SelectionSet, with context: ConfigurationContext) throws {
+    // Check for type conflicts resulting from singularization/pluralization of fields
+    var typeNames = [String: String]()
+    var fields: [IR.EntityField] = selectionSet.selections.direct?.fields.values.compactMap({ $0 as? IR.EntityField }) ?? []
+    fields.append(contentsOf: selectionSet.selections.merged.fields.values.compactMap({ $0 as? IR.EntityField }))
+
+    try fields.forEach({ field in
+      let formattedTypeName = field.formattedSelectionSetName(with: context.pluralizer)
+      if let existingFieldName = typeNames[formattedTypeName] {
+        throw Error.typeNameConflict(name: existingFieldName, conflictingName: field.name)
+      }
+
+      typeNames[formattedTypeName] = field.name
+      try validateTypeConflicts(for: field.selectionSet, with: context)
+    })
+  }
 
   /// Performs GraphQL source validation and compiles the schema and operation source documents.
   static func compileGraphQLResult(
@@ -304,6 +328,7 @@ public class ApolloCodegen {
     for fragment in compilationResult.fragments {
       try autoreleasepool {
         let irFragment = ir.build(fragment: fragment)
+        try validateTypeConflicts(for: irFragment.rootField.selectionSet, with: config)
         try FragmentFileGenerator(irFragment: irFragment, config: config)
           .generate(forConfig: config, fileManager: fileManager)
       }
@@ -314,6 +339,7 @@ public class ApolloCodegen {
     for operation in compilationResult.operations {
       try autoreleasepool {
         let irOperation = ir.build(operation: operation)
+        try validateTypeConflicts(for: irOperation.rootField.selectionSet, with: config)
         try OperationFileGenerator(irOperation: irOperation, config: config)
           .generate(forConfig: config, fileManager: fileManager)
 

Sources/ApolloCodegenLib/Templates/SelectionSetTemplate.swift

@@ -624,7 +624,7 @@ fileprivate extension IR.SelectionSet {
 
 }
 
-fileprivate extension IR.EntityField {
+extension IR.EntityField {
 
   func formattedSelectionSetName(
     with pluralizer: Pluralizer

Tests/ApolloCodegenTests/ApolloCodegenTests.swift

@@ -2334,6 +2334,78 @@ class ApolloCodegenTests: XCTestCase {
     // then
     expect(try ApolloCodegen._validate(config: config)).notTo(throwError())
   }
+
+  func test__validation__selectionSet_typeConflicts_shouldThrowError() throws {
+    let schemaDefData: Data = {
+      """
+      type Query {
+        user: User
+      }
+
+      type User {
+        containers: [Container]
+      }
+
+      type Container {
+        value: Value
+        values: [Value]
+      }
+
+      type Value {
+        propertyA: String!
+        propertyB: String!
+        propertyC: String!
+        propertyD: String!
+      }
+      """
+    }().data(using: .utf8)!
+
+    let operationData: Data =
+      """
+      query ConflictingQuery {
+          user {
+              containers {
+                  value {
+                      propertyA
+                      propertyB
+                      propertyC
+                      propertyD
+                  }
+
+                  values {
+                      propertyA
+                      propertyC
+                  }
+              }
+          }
+      }
+      """.data(using: .utf8)!
+
+    try createFile(containing: schemaDefData, named: "schema.graphqls")
+    try createFile(containing: operationData, named: "operation.graphql")
+
+    let config = ApolloCodegenConfiguration.mock(
+      input: .init(
+        schemaSearchPaths: ["schema*.graphqls"],
+        operationSearchPaths: ["*.graphql"]
+      ),
+      output: .init(
+        schemaTypes: .init(path: "SchemaModule",
+                           moduleType: .swiftPackageManager),
+        operations: .inSchemaModule
+      )
+    )
+
+    expect(try ApolloCodegen.build(with: config))
+      .to(throwError { error in
+        guard case let ApolloCodegen.Error.typeNameConflict(name, conflictingName) = error else {
+          fail("Expected .typeNameConflict, got .\(error)")
+          return
+        }
+        expect(name).to(equal("value"))
+        expect(conflictingName).to(equal("values"))
+      })
+  }
 
   // MARK: Path Match Exclusion Tests