Refactor instruction definitions

lib/src/main/java/graphql/nadel/NadelSchemas.kt

@@ -202,11 +202,11 @@ data class NadelSchemas(
             val underlyingSchemaGenerator = UnderlyingSchemaGenerator()
 
             return builder.overallSchemaReaders.map { (serviceName, reader) ->
-                val nadelDefinitions = SchemaUtil.parseSchemaDefinitions(
+                val schemaDefinitions = SchemaUtil.parseSchemaDefinitions(
                     reader,
                     captureSourceLocation = captureSourceLocation,
                 )
-                val nadelDefinitionRegistry = NadelDefinitionRegistry.from(nadelDefinitions)
+                val typeDefinitionRegistry = NadelTypeDefinitionRegistry.from(schemaDefinitions)
 
                 // Builder should enforce non-null entry
                 val underlyingSchema = underlyingSchemaGenerator.buildUnderlyingSchema(
@@ -217,7 +217,7 @@ data class NadelSchemas(
 
                 val serviceExecution = serviceExecutionFactory.getServiceExecution(serviceName)
 
-                Service(serviceName, underlyingSchema, serviceExecution, nadelDefinitionRegistry)
+                Service(serviceName, underlyingSchema, serviceExecution, typeDefinitionRegistry)
             }
         }
 

lib/src/main/java/graphql/nadel/NadelDefinitionRegistry.kt → lib/src/main/java/graphql/nadel/NadelTypeDefinitionRegistry.kt

@@ -12,7 +12,7 @@ import java.util.Collections
  * Alternative to [graphql.schema.idl.TypeDefinitionRegistry] but is more generic
  * and tailored to Nadel specific operations to build the overall schema.
  */
-class NadelDefinitionRegistry {
+class NadelTypeDefinitionRegistry {
     private val _definitions: MutableList<AnySDLDefinition> = ArrayList()
     private val definitionsByClass = LinkedHashMap<Class<out AnySDLDefinition>, MutableList<AnySDLDefinition>>()
     private val definitionsByName = LinkedHashMap<String, MutableList<AnySDLDefinition>>()
@@ -101,8 +101,8 @@ class NadelDefinitionRegistry {
 
     companion object {
         @JvmStatic
-        fun from(definitions: List<AnySDLDefinition>): NadelDefinitionRegistry {
-            val registry = NadelDefinitionRegistry()
+        fun from(definitions: List<AnySDLDefinition>): NadelTypeDefinitionRegistry {
+            val registry = NadelTypeDefinitionRegistry()
             definitions.forEach(registry::add)
             return registry
         }

lib/src/main/java/graphql/nadel/Service.kt

@@ -16,7 +16,7 @@ open class Service(
     /**
      * These are the GraphQL definitions that a service contributes to the OVERALL schema.
      */
-    val definitionRegistry: NadelDefinitionRegistry,
+    val definitionRegistry: NadelTypeDefinitionRegistry,
 ) {
     override fun toString(): String {
         return "Service{name='$name'}"

lib/src/main/java/graphql/nadel/definition/NadelInstructionDefinition.kt

@@ -0,0 +1,3 @@
+package graphql.nadel.definition
+
+interface NadelInstructionDefinition

lib/src/main/java/graphql/nadel/definition/NadelSchemaMemberCoordinates.kt

@@ -1,5 +1,6 @@
 package graphql.nadel.definition
 
+import graphql.nadel.engine.blueprint.NadelSchemaTraverserElement
 import graphql.schema.GraphQLDirective
 import graphql.schema.GraphQLEnumType
 import graphql.schema.GraphQLFieldsContainer
@@ -168,3 +169,14 @@ fun GraphQLNamedType.coordinates(): NadelSchemaMemberCoordinates.Type {
         else -> throw IllegalArgumentException(javaClass.name)
     }
 }
+
+internal fun NadelSchemaTraverserElement.Type.coordinates(): NadelSchemaMemberCoordinates.Type {
+    return when (this) {
+        is NadelSchemaTraverserElement.EnumType -> NadelSchemaMemberCoordinates.Enum(node.name)
+        is NadelSchemaTraverserElement.InputObjectType -> NadelSchemaMemberCoordinates.InputObject(node.name)
+        is NadelSchemaTraverserElement.ScalarType -> NadelSchemaMemberCoordinates.Scalar(node.name)
+        is NadelSchemaTraverserElement.InterfaceType -> NadelSchemaMemberCoordinates.Interface(node.name)
+        is NadelSchemaTraverserElement.ObjectType -> NadelSchemaMemberCoordinates.Object(node.name)
+        is NadelSchemaTraverserElement.UnionType -> NadelSchemaMemberCoordinates.Union(node.name)
+    }
+}

lib/src/main/java/graphql/nadel/definition/hydration/NadelHydrationDefinition.kt

@@ -4,40 +4,27 @@ import graphql.language.ArrayValue
 import graphql.language.DirectiveDefinition
 import graphql.language.FieldDefinition
 import graphql.language.ObjectValue
-import graphql.nadel.definition.NadelDefinition
+import graphql.nadel.definition.NadelInstructionDefinition
 import graphql.nadel.definition.hydration.NadelHydrationDefinition.Keyword
 import graphql.nadel.engine.util.JsonMap
 import graphql.nadel.engine.util.parseDefinition
-import graphql.nadel.validation.NadelValidationContext
 import graphql.schema.GraphQLAppliedDirective
 import graphql.schema.GraphQLFieldDefinition
 
 fun FieldDefinition.hasHydratedDefinition(): Boolean {
     return hasDirective(Keyword.hydrated)
 }
 
-context(NadelValidationContext)
-@Deprecated("Mistake to use this inside validation", level = DeprecationLevel.ERROR)
-fun GraphQLFieldDefinition.hasHydratedDefinition(): Nothing {
-    throw UnsupportedOperationException()
-}
-
 fun GraphQLFieldDefinition.hasHydratedDefinition(): Boolean {
     return hasAppliedDirective(Keyword.hydrated)
 }
 
-context(NadelValidationContext)
-@Deprecated("Mistake to use this inside validation", level = DeprecationLevel.ERROR)
-fun GraphQLFieldDefinition.parseHydrationDefinitions(): Nothing {
-    throw UnsupportedOperationException()
-}
-
 fun GraphQLFieldDefinition.parseHydrationDefinitions(): List<NadelHydrationDefinition> {
     return getAppliedDirectives(Keyword.hydrated)
         .map(::NadelHydrationDefinitionImpl)
 }
 
-interface NadelHydrationDefinition : NadelDefinition {
+interface NadelHydrationDefinition : NadelInstructionDefinition {
     companion object {
         val directiveDefinition = parseDefinition<DirectiveDefinition>(
             // language=GraphQL

lib/src/main/java/graphql/nadel/definition/partition/NadelPartitionDefinition.kt

@@ -2,15 +2,15 @@ package graphql.nadel.definition.partition
 
 import graphql.language.DirectiveDefinition
 import graphql.language.FieldDefinition
-import graphql.nadel.definition.NadelDefinition
+import graphql.nadel.definition.NadelInstructionDefinition
 import graphql.nadel.definition.partition.NadelPartitionDefinition.Keyword
 import graphql.nadel.engine.util.parseDefinition
 import graphql.schema.GraphQLAppliedDirective
 import graphql.schema.GraphQLFieldDefinition
 
 class NadelPartitionDefinition(
     private val appliedDirective: GraphQLAppliedDirective,
-) : NadelDefinition {
+) : NadelInstructionDefinition {
     companion object {
         val directiveDefinition = parseDefinition<DirectiveDefinition>(
             // language=GraphQL

lib/src/main/java/graphql/nadel/definition/renamed/NadelRenamedDefinition.kt

@@ -2,7 +2,7 @@ package graphql.nadel.definition.renamed
 
 import graphql.language.DirectiveDefinition
 import graphql.language.DirectivesContainer
-import graphql.nadel.definition.NadelDefinition
+import graphql.nadel.definition.NadelInstructionDefinition
 import graphql.nadel.definition.renamed.NadelRenamedDefinition.Keyword
 import graphql.nadel.engine.util.parseDefinition
 import graphql.nadel.validation.NadelValidationContext
@@ -11,7 +11,7 @@ import graphql.schema.GraphQLDirectiveContainer
 import graphql.schema.GraphQLFieldDefinition
 import graphql.schema.GraphQLNamedType
 
-sealed class NadelRenamedDefinition : NadelDefinition {
+sealed class NadelRenamedDefinition : NadelInstructionDefinition {
     companion object {
         val directiveDefinition = parseDefinition<DirectiveDefinition>(
             // language=GraphQL
@@ -48,12 +48,6 @@ sealed class NadelRenamedDefinition : NadelDefinition {
     }
 }
 
-context(NadelValidationContext)
-@Deprecated("Mistake to use this inside validation", level = DeprecationLevel.ERROR)
-fun GraphQLDirectiveContainer.hasRenameDefinition(): Nothing {
-    throw UnsupportedOperationException()
-}
-
 fun GraphQLDirectiveContainer.hasRenameDefinition(): Boolean {
     return hasAppliedDirective(Keyword.renamed)
 }
@@ -62,25 +56,13 @@ fun DirectivesContainer<*>.hasRenameDefinition(): Boolean {
     return hasDirective(Keyword.renamed)
 }
 
-context(NadelValidationContext)
-@Deprecated("Mistake to use this inside validation", level = DeprecationLevel.ERROR)
-fun GraphQLFieldDefinition.parseRenamedOrNull(): Nothing {
-    throw UnsupportedOperationException()
-}
-
 fun GraphQLFieldDefinition.parseRenamedOrNull(): NadelRenamedDefinition.Field? {
     val directive = getAppliedDirective(Keyword.renamed)
         ?: return null
 
     return NadelRenamedDefinition.Field(directive)
 }
 
-context(NadelValidationContext)
-@Deprecated("Mistake to use this inside validation", level = DeprecationLevel.ERROR)
-fun GraphQLNamedType.parseRenamedOrNull(): Nothing {
-    throw UnsupportedOperationException()
-}
-
 fun GraphQLNamedType.parseRenamedOrNull(): NadelRenamedDefinition.Type? {
     val directive = (this as GraphQLDirectiveContainer).getAppliedDirective(Keyword.renamed)
         ?: return null

lib/src/main/java/graphql/nadel/definition/virtualType/NadelVirtualTypeDefinition.kt

@@ -2,7 +2,7 @@ package graphql.nadel.definition.virtualType
 
 import graphql.language.DirectiveDefinition
 import graphql.language.DirectivesContainer
-import graphql.nadel.definition.NadelDefinition
+import graphql.nadel.definition.NadelInstructionDefinition
 import graphql.nadel.engine.util.parseDefinition
 import graphql.schema.GraphQLDirectiveContainer
 import graphql.schema.GraphQLSchemaElement
@@ -16,7 +16,7 @@ internal fun DirectivesContainer<*>.hasVirtualTypeDefinition(): Boolean {
     return hasDirective(NadelVirtualTypeDefinition.directiveDefinition.name)
 }
 
-internal class NadelVirtualTypeDefinition : NadelDefinition {
+internal class NadelVirtualTypeDefinition : NadelInstructionDefinition {
     companion object {
         val directiveDefinition = parseDefinition<DirectiveDefinition>(
             // language=GraphQL

lib/src/main/java/graphql/nadel/engine/blueprint/IntrospectionService.kt

@@ -4,7 +4,7 @@ import graphql.ExecutionInput
 import graphql.GraphQL
 import graphql.GraphqlErrorHelper.toSpecification
 import graphql.language.AstPrinter
-import graphql.nadel.NadelDefinitionRegistry
+import graphql.nadel.NadelTypeDefinitionRegistry
 import graphql.nadel.Service
 import graphql.nadel.ServiceExecution
 import graphql.nadel.ServiceExecutionParameters
@@ -24,7 +24,7 @@ import java.util.concurrent.CompletableFuture
 internal class IntrospectionService(
     schema: GraphQLSchema,
     introspectionRunnerFactory: NadelIntrospectionRunnerFactory,
-) : Service(name, schema, introspectionRunnerFactory.make(schema), NadelDefinitionRegistry()) {
+) : Service(name, schema, introspectionRunnerFactory.make(schema), NadelTypeDefinitionRegistry()) {
     companion object {
         const val name = "__introspection"
     }

lib/src/main/java/graphql/nadel/schema/OverallSchemaGenerator.kt

@@ -7,7 +7,7 @@ import graphql.language.ObjectTypeDefinition.newObjectTypeDefinition
 import graphql.language.ScalarTypeDefinition.newScalarTypeDefinition
 import graphql.language.SchemaDefinition
 import graphql.language.SourceLocation
-import graphql.nadel.NadelDefinitionRegistry
+import graphql.nadel.NadelTypeDefinitionRegistry
 import graphql.nadel.NadelOperationKind
 import graphql.nadel.util.AnyNamedNode
 import graphql.nadel.util.AnySDLDefinition
@@ -22,7 +22,7 @@ import graphql.schema.idl.WiringFactory
 
 internal class OverallSchemaGenerator {
     fun buildOverallSchema(
-        serviceRegistries: List<NadelDefinitionRegistry>,
+        serviceRegistries: List<NadelTypeDefinitionRegistry>,
         wiringFactory: WiringFactory,
     ): GraphQLSchema {
         val schemaGenerator = SchemaGenerator()
@@ -33,7 +33,7 @@ internal class OverallSchemaGenerator {
         return schemaGenerator.makeExecutableSchema(createTypeRegistry(serviceRegistries), runtimeWiring)
     }
 
-    private fun createTypeRegistry(serviceRegistries: List<NadelDefinitionRegistry>): TypeDefinitionRegistry {
+    private fun createTypeRegistry(serviceRegistries: List<NadelTypeDefinitionRegistry>): TypeDefinitionRegistry {
         val topLevelFields = NadelOperationKind.entries
             .associateWith {
                 mutableListOf<FieldDefinition>()
@@ -128,7 +128,7 @@ internal class OverallSchemaGenerator {
     private fun collectTypes(
         topLevelFields: Map<NadelOperationKind, MutableList<FieldDefinition>>,
         allDefinitions: MutableList<AnySDLDefinition>,
-        definitionRegistry: NadelDefinitionRegistry,
+        definitionRegistry: NadelTypeDefinitionRegistry,
     ) {
         val opDefinitions = definitionRegistry.operationMap
         val opTypeNames: MutableSet<String> = HashSet(3)

lib/src/main/java/graphql/nadel/validation/NadelAssignableTypeValidation.kt

@@ -0,0 +1,59 @@
+package graphql.nadel.validation
+
+import graphql.nadel.engine.util.unwrapAll
+import graphql.schema.GraphQLType
+
+class NadelAssignableTypeValidation internal constructor(
+    private val typeWrappingValidation: NadelTypeWrappingValidation,
+) {
+    context(NadelValidationContext)
+    fun isOutputTypeAssignable(
+        overallType: GraphQLType,
+        underlyingType: GraphQLType,
+    ): Boolean {
+        // Note: the (supplied) value comes from the underlying service, and that value needs to fit the (required) overall field's type
+        return isTypeAssignable(
+            suppliedType = underlyingType,
+            requiredType = overallType,
+            // Compare underlying type names
+            suppliedTypeName = underlyingType.unwrapAll().name,
+            requiredTypeName = instructionDefinitions.getUnderlyingTypeName(overallType.unwrapAll()),
+        )
+    }
+
+    context(NadelValidationContext)
+    fun isInputTypeAssignable(
+        overallType: GraphQLType,
+        underlyingType: GraphQLType,
+    ): Boolean {
+        // Note: the (supplied) value comes from the user (overall schema) and needs to be assigned to the (required) underlying type
+        return isTypeAssignable(
+            suppliedType = overallType,
+            requiredType = underlyingType,
+            // Compare underlying type names
+            suppliedTypeName = instructionDefinitions.getUnderlyingTypeName(overallType.unwrapAll()),
+            requiredTypeName = underlyingType.unwrapAll().name,
+        )
+    }
+
+    context(NadelValidationContext)
+    fun isTypeAssignable(
+        suppliedType: GraphQLType,
+        requiredType: GraphQLType,
+        suppliedTypeName: String,
+        requiredTypeName: String,
+    ): Boolean {
+        return suppliedTypeName == requiredTypeName && isTypeWrappingValid(suppliedType, requiredType)
+    }
+
+    private fun isTypeWrappingValid(
+        suppliedType: GraphQLType,
+        requiredType: GraphQLType,
+    ): Boolean {
+        return typeWrappingValidation.isTypeWrappingValid(
+            lhs = suppliedType,
+            rhs = requiredType,
+            rule = NadelTypeWrappingValidation.Rule.LHS_MUST_BE_STRICTER_OR_SAME,
+        )
+    }
+}