Merge pull request #5282 from gmac/from_definition_base_types

Base type classes for `Schema.from_definition`

Author: rmosolgo

lib/graphql/schema.rb

@@ -111,7 +111,7 @@ def from_introspection(introspection_result)
       # @param parser [Object] An object for handling definition string parsing (must respond to `parse`)
       # @param using [Hash] Plugins to attach to the created schema with `use(key, value)`
       # @return [Class] the schema described by `document`
-      def from_definition(definition_or_path, default_resolve: nil, parser: GraphQL.default_parser, using: {})
+      def from_definition(definition_or_path, default_resolve: nil, parser: GraphQL.default_parser, using: {}, base_types: {})
         # If the file ends in `.graphql` or `.graphqls`, treat it like a filepath
         if definition_or_path.end_with?(".graphql") || definition_or_path.end_with?(".graphqls")
           GraphQL::Schema::BuildFromDefinition.from_definition_path(
@@ -120,6 +120,7 @@ def from_definition(definition_or_path, default_resolve: nil, parser: GraphQL.de
             default_resolve: default_resolve,
             parser: parser,
             using: using,
+            base_types: base_types,
           )
         else
           GraphQL::Schema::BuildFromDefinition.from_definition(
@@ -128,6 +129,7 @@ def from_definition(definition_or_path, default_resolve: nil, parser: GraphQL.de
             default_resolve: default_resolve,
             parser: parser,
             using: using,
+            base_types: base_types,
           )
         end
       end

lib/graphql/schema/build_from_definition.rb

@@ -20,8 +20,8 @@ def from_definition_path(schema_superclass, definition_path, parser: GraphQL.def
           from_document(schema_superclass, parser.parse_file(definition_path), **kwargs)
         end
 
-        def from_document(schema_superclass, document, default_resolve:, using: {}, relay: false)
-          Builder.build(schema_superclass, document, default_resolve: default_resolve || {}, relay: relay, using: using)
+        def from_document(schema_superclass, document, default_resolve:, using: {}, base_types: {}, relay: false)
+          Builder.build(schema_superclass, document, default_resolve: default_resolve || {}, relay: relay, using: using, base_types: base_types)
         end
       end
 
@@ -30,9 +30,18 @@ module Builder
         include GraphQL::EmptyObjects
         extend self
 
-        def build(schema_superclass, document, default_resolve:, using: {}, relay:)
+        def build(schema_superclass, document, default_resolve:, using: {}, base_types: {}, relay:)
           raise InvalidDocumentError.new('Must provide a document ast.') if !document || !document.is_a?(GraphQL::Language::Nodes::Document)
 
+          base_types = {
+            object: GraphQL::Schema::Object,
+            interface: GraphQL::Schema::Interface,
+            union: GraphQL::Schema::Union,
+            scalar: GraphQL::Schema::Scalar,
+            enum: GraphQL::Schema::Enum,
+            input_object: GraphQL::Schema::InputObject,
+          }.merge!(base_types)
+
           if default_resolve.is_a?(Hash)
             default_resolve = ResolveMap.new(default_resolve)
           end
@@ -53,7 +62,7 @@ def build(schema_superclass, document, default_resolve:, using: {}, relay:)
             types[type_name] ||= begin
               defn = document.definitions.find { |d| d.respond_to?(:name) && d.name == type_name }
               if defn
-                build_definition_from_node(defn, directive_type_resolver, default_resolve)
+                build_definition_from_node(defn, directive_type_resolver, default_resolve, base_types)
               elsif (built_in_defn = GraphQL::Schema::BUILT_IN_TYPES[type_name])
                 built_in_defn
               else
@@ -84,7 +93,7 @@ def build(schema_superclass, document, default_resolve:, using: {}, relay:)
               # It's possible that this was already loaded by the directives
               prev_type = types[definition.name]
               if prev_type.nil? || prev_type.is_a?(Schema::LateBoundType)
-                types[definition.name] = build_definition_from_node(definition, type_resolver, default_resolve)
+                types[definition.name] = build_definition_from_node(definition, type_resolver, default_resolve, base_types)
               end
             end
           end
@@ -205,20 +214,20 @@ def self.inherited(child_class)
           raise(GraphQL::RequiredImplementationMissingError, "Generated Schema cannot use Interface or Union types for execution. Implement resolve_type on your resolver.")
         }
 
-        def build_definition_from_node(definition, type_resolver, default_resolve)
+        def build_definition_from_node(definition, type_resolver, default_resolve, base_types)
           case definition
           when GraphQL::Language::Nodes::EnumTypeDefinition
-            build_enum_type(definition, type_resolver)
+            build_enum_type(definition, type_resolver, base_types[:enum])
           when GraphQL::Language::Nodes::ObjectTypeDefinition
-            build_object_type(definition, type_resolver)
+            build_object_type(definition, type_resolver, base_types[:object])
           when GraphQL::Language::Nodes::InterfaceTypeDefinition
-            build_interface_type(definition, type_resolver)
+            build_interface_type(definition, type_resolver, base_types[:interface])
           when GraphQL::Language::Nodes::UnionTypeDefinition
-            build_union_type(definition, type_resolver)
+            build_union_type(definition, type_resolver, base_types[:union])
           when GraphQL::Language::Nodes::ScalarTypeDefinition
-            build_scalar_type(definition, type_resolver, default_resolve: default_resolve)
+            build_scalar_type(definition, type_resolver, base_types[:scalar], default_resolve: default_resolve)
           when GraphQL::Language::Nodes::InputObjectTypeDefinition
-            build_input_object_type(definition, type_resolver)
+            build_input_object_type(definition, type_resolver, base_types[:input_object])
           end
         end
 
@@ -284,9 +293,9 @@ def args_to_kwargs(arg_owner, node)
           end
         end
 
-        def build_enum_type(enum_type_definition, type_resolver)
+        def build_enum_type(enum_type_definition, type_resolver, base_type)
           builder = self
-          Class.new(GraphQL::Schema::Enum) do
+          Class.new(base_type) do
             graphql_name(enum_type_definition.name)
             builder.build_directives(self, enum_type_definition, type_resolver)
             description(enum_type_definition.description)
@@ -313,9 +322,9 @@ def build_deprecation_reason(directives)
           reason.value
         end
 
-        def build_scalar_type(scalar_type_definition, type_resolver, default_resolve:)
+        def build_scalar_type(scalar_type_definition, type_resolver, base_type, default_resolve:)
           builder = self
-          Class.new(GraphQL::Schema::Scalar) do
+          Class.new(base_type) do
             graphql_name(scalar_type_definition.name)
             description(scalar_type_definition.description)
             ast_node(scalar_type_definition)
@@ -336,9 +345,9 @@ def build_scalar_type_coerce_method(scalar_class, method_name, default_definitio
           end
         end
 
-        def build_union_type(union_type_definition, type_resolver)
+        def build_union_type(union_type_definition, type_resolver, base_type)
           builder = self
-          Class.new(GraphQL::Schema::Union) do
+          Class.new(base_type) do
             graphql_name(union_type_definition.name)
             description(union_type_definition.description)
             possible_types(*union_type_definition.types.map { |type_name| type_resolver.call(type_name) })
@@ -347,10 +356,10 @@ def build_union_type(union_type_definition, type_resolver)
           end
         end
 
-        def build_object_type(object_type_definition, type_resolver)
+        def build_object_type(object_type_definition, type_resolver, base_type)
           builder = self
 
-          Class.new(GraphQL::Schema::Object) do
+          Class.new(base_type) do
             graphql_name(object_type_definition.name)
             description(object_type_definition.description)
             ast_node(object_type_definition)
@@ -365,9 +374,9 @@ def build_object_type(object_type_definition, type_resolver)
           end
         end
 
-        def build_input_object_type(input_object_type_definition, type_resolver)
+        def build_input_object_type(input_object_type_definition, type_resolver, base_type)
           builder = self
-          Class.new(GraphQL::Schema::InputObject) do
+          Class.new(base_type) do
             graphql_name(input_object_type_definition.name)
             description(input_object_type_definition.description)
             ast_node(input_object_type_definition)
@@ -427,10 +436,10 @@ def build_directive(directive_definition, type_resolver)
           end
         end
 
-        def build_interface_type(interface_type_definition, type_resolver)
+        def build_interface_type(interface_type_definition, type_resolver, base_type)
           builder = self
           Module.new do
-            include GraphQL::Schema::Interface
+            include base_type
             graphql_name(interface_type_definition.name)
             description(interface_type_definition.description)
             interface_type_definition.interfaces.each do |interface_name|

spec/graphql/schema/build_from_definition_spec.rb

@@ -1750,6 +1750,48 @@ def coerce_result(type, value, ctx)
     assert_equal schema_str, schema.to_definition
   end
 
+  describe "Custom base types" do
+    class MyObject < GraphQL::Schema::Object; end
+    class MyUnion < GraphQL::Schema::Union; end
+    class MyScalar < GraphQL::Schema::Scalar; end
+    class MyEnum < GraphQL::Schema::Enum; end
+    class MyInputObject < GraphQL::Schema::InputObject; end
+    module MyInterface
+      include GraphQL::Schema::Interface
+    end
+
+    it "Builds a schema using custom base types" do
+      schema = GraphQL::Schema.from_definition(%|
+        interface A { a:Int }
+        type B implements A { a:Int }
+        union C = B
+        scalar D
+        enum E { YES }
+        input F { f:Int }
+        type Query {
+          a(f:F): A
+          c: C
+          d: D
+          e: E
+        }
+      |, base_types: {
+        object: MyObject,
+        interface: MyInterface,
+        union: MyUnion,
+        scalar: MyScalar,
+        enum: MyEnum,
+        input_object: MyInputObject,
+      })
+
+      assert schema.get_type("A") <= MyInterface
+      assert schema.get_type("B") <= MyObject
+      assert schema.get_type("C") <= MyUnion
+      assert schema.get_type("D") <= MyScalar
+      assert schema.get_type("E") <= MyEnum
+      assert schema.get_type("F") <= MyInputObject
+    end
+  end
+
   if USING_C_PARSER
     it "makes frozen identifiers with CParser" do
       schema_class = GraphQL::Schema.from_definition("type Query { f: Boolean }")