refactor(Schema) create schemas with Schema.define

Author: rmosolgo

lib/graphql.rb

@@ -1,7 +1,6 @@
 require "json"
 require "set"
 require "singleton"
-require "forwardable"
 
 module GraphQL
   class Error < StandardError

lib/graphql/query.rb

@@ -50,7 +50,6 @@ def initialize(schema, query_string = nil, document: nil, context: nil, variable
       @operations = {}
       @provided_variables = variables
       @query_string = query_string
-
       @document = document || GraphQL.parse(query_string)
       @document.definitions.each do |part|
         if part.is_a?(GraphQL::Language::Nodes::FragmentDefinition)

lib/graphql/schema.rb

@@ -11,33 +11,83 @@
 
 module GraphQL
   # A GraphQL schema which may be queried with {GraphQL::Query}.
+  #
+  # The {Schema} contains:
+  #
+  #  - types for exposing your application
+  #  - query analyzers for assessing incoming queries (including max depth & max complexity restrictions)
+  #  - execution strategies for running incoming queries
+  #  - middleware for interacting with execution
+  #
+  # Schemas start with root types, {Schema#query}, {Schema#mutation} and {Schema#subscription}.
+  # The schema will traverse the tree of fields & types, using those as starting points.
+  # Any undiscoverable types may be provided with the `types` configuration.
+  #
+  # Schemas can restrict large incoming queries with `max_depth` and `max_complexity` configurations.
+  # (These configurations can be overridden by specific calls to {Schema#execute})
+  #
+  # Schemas can specify how queries should be executed against them.
+  # `query_execution_strategy`, `mutation_execution_strategy` and `subscription_execution_strategy`
+  # each apply to corresponding root types.
+  #
+  # A schema accepts a `Relay::GlobalNodeIdentification` instance for use with Relay IDs.
+  #
+  # @example defining a schema
+  #   MySchema = GraphQL::Schema.define do
+  #     query QueryType
+  #     middleware PermissionMiddleware
+  #     rescue_from(ActiveRecord::RecordNotFound) { "Not found" }
+  #     # If types are only connected by way of interfaces, they must be added here
+  #     orphan_types ImageType, AudioType
+  #   end
+  #
   class Schema
-    extend Forwardable
+    include GraphQL::Define::InstanceDefinable
+    accepts_definitions \
+      :query, :mutation, :subscription,
+      :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
+      :max_depth, :max_complexity,
+      :node_identification,
+      :orphan_types,
+      query_analyzer: -> (schema, analyzer) { schema.query_analyzers << analyzer },
+      middleware: -> (schema, middleware) { schema.middleware << middleware },
+      rescue_from: -> (schema, err_class, &block) { schema.rescue_from(err_class, &block)}
+
+    lazy_defined_attr_accessor \
+      :query, :mutation, :subscription,
+      :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
+      :max_depth, :max_complexity,
+      :node_identification,
+      :orphan_types,
+      :query_analyzers, :middleware
+
 
     DIRECTIVES = [GraphQL::Directive::SkipDirective, GraphQL::Directive::IncludeDirective]
     DYNAMIC_FIELDS = ["__type", "__typename", "__schema"]
 
-    attr_reader :query, :mutation, :subscription, :directives, :static_validator, :query_analyzers
-    attr_accessor :max_depth
-    attr_accessor :max_complexity
-
-    # Override these if you don't want the default executor:
-    attr_accessor :query_execution_strategy,
-      :mutation_execution_strategy,
-      :subscription_execution_strategy
+    attr_reader :directives, :static_validator
 
     # @return [GraphQL::Relay::GlobalNodeIdentification] the node identification instance for this schema, when using Relay
-    attr_accessor :node_identification
+    def node_identification
+      ensure_defined
+      @node_identification
+    end
 
     # @return [Array<#call>] Middlewares suitable for MiddlewareChain, applied to fields during execution
-    attr_reader :middleware
+    def middleware
+      ensure_defined
+      @middleware
+    end
 
     # @param query [GraphQL::ObjectType]  the query root for the schema
     # @param mutation [GraphQL::ObjectType] the mutation root for the schema
     # @param subscription [GraphQL::ObjectType] the subscription root for the schema
     # @param max_depth [Integer] maximum query nesting (if it's greater, raise an error)
     # @param types [Array<GraphQL::BaseType>] additional types to include in this schema
-    def initialize(query:, mutation: nil, subscription: nil, max_depth: nil, max_complexity: nil, types: [])
+    def initialize(query: nil, mutation: nil, subscription: nil, max_depth: nil, max_complexity: nil, types: [])
+      if query
+        warn("Schema.new is deprecated, use Schema.define instead")
+      end
       @query    = query
       @mutation = mutation
       @subscription = subscription
@@ -50,17 +100,26 @@ def initialize(query:, mutation: nil, subscription: nil, max_depth: nil, max_com
       @middleware = [@rescue_middleware]
       @query_analyzers = []
       # Default to the built-in execution strategy:
-      self.query_execution_strategy = GraphQL::Query::SerialExecution
-      self.mutation_execution_strategy = GraphQL::Query::SerialExecution
-      self.subscription_execution_strategy = GraphQL::Query::SerialExecution
+      @query_execution_strategy = GraphQL::Query::SerialExecution
+      @mutation_execution_strategy = GraphQL::Query::SerialExecution
+      @subscription_execution_strategy = GraphQL::Query::SerialExecution
+    end
+
+    def rescue_from(*args, &block)
+      ensure_defined
+      @rescue_middleware.rescue_from(*args, &block)
     end
 
-    def_delegators :@rescue_middleware, :rescue_from, :remove_handler
+    def remove_handler(*args, &block)
+      ensure_defined
+      @rescue_middleware.remove_handler(*args, &block)
+    end
 
     # @return [GraphQL::Schema::TypeMap] `{ name => type }` pairs of types in this schema
     def types
       @types ||= begin
-        all_types = @orphan_types + [query, mutation, subscription, GraphQL::Introspection::SchemaType]
+        ensure_defined
+        all_types = orphan_types + [query, mutation, subscription, GraphQL::Introspection::SchemaType]
         GraphQL::Schema::ReduceTypes.reduce(all_types.compact)
       end
     end
@@ -69,13 +128,14 @@ def types
     # See {Query#initialize} for arguments.
     # @return [Hash] query result, ready to be serialized as JSON
     def execute(*args)
-      query = GraphQL::Query.new(self, *args)
-      query.result
+      query_obj = GraphQL::Query.new(self, *args)
+      query_obj.result
     end
 
     # Resolve field named `field_name` for type `parent_type`.
     # Handles dynamic fields `__typename`, `__type` and `__schema`, too
     def get_field(parent_type, field_name)
+      ensure_defined
       defined_field = parent_type.get_field(field_name)
       if defined_field
         defined_field
@@ -91,12 +151,14 @@ def get_field(parent_type, field_name)
     end
 
     def type_from_ast(ast_node)
+      ensure_defined
       GraphQL::Schema::TypeExpression.build_type(self, ast_node)
     end
 
     # @param type_defn [GraphQL::InterfaceType, GraphQL::UnionType] the type whose members you want to retrieve
     # @return [Array<GraphQL::ObjectType>] types which belong to `type_defn` in this schema
     def possible_types(type_defn)
+      ensure_defined
       @interface_possible_types ||= GraphQL::Schema::PossibleTypes.new(self)
       @interface_possible_types.possible_types(type_defn)
     end

spec/graphql/relay/array_connection_spec.rb

@@ -33,66 +33,66 @@ def get_last_cursor(result)
     |}
 
     it 'limits the result' do
-      result = query(query_string, "first" => 2)
+      result = star_wars_query(query_string, "first" => 2)
       number_of_ships = get_names(result).length
       assert_equal(2, number_of_ships)
       assert_equal(true, result["data"]["rebels"]["ships"]["pageInfo"]["hasNextPage"])
       assert_equal(false, result["data"]["rebels"]["ships"]["pageInfo"]["hasPreviousPage"])
       assert_equal("MQ==", result["data"]["rebels"]["ships"]["pageInfo"]["startCursor"])
       assert_equal("Mg==", result["data"]["rebels"]["ships"]["pageInfo"]["endCursor"])
 
-      result = query(query_string, "first" => 3)
+      result = star_wars_query(query_string, "first" => 3)
       number_of_ships = get_names(result).length
       assert_equal(3, number_of_ships)
     end
 
     it 'provides pageInfo' do
-      result = query(query_string, "first" => 2)
+      result = star_wars_query(query_string, "first" => 2)
       assert_equal(true, result["data"]["rebels"]["ships"]["pageInfo"]["hasNextPage"])
       assert_equal(false, result["data"]["rebels"]["ships"]["pageInfo"]["hasPreviousPage"])
       assert_equal("MQ==", result["data"]["rebels"]["ships"]["pageInfo"]["startCursor"])
       assert_equal("Mg==", result["data"]["rebels"]["ships"]["pageInfo"]["endCursor"])
 
-      result = query(query_string, "first" => 100)
+      result = star_wars_query(query_string, "first" => 100)
       assert_equal(false, result["data"]["rebels"]["ships"]["pageInfo"]["hasNextPage"])
       assert_equal(false, result["data"]["rebels"]["ships"]["pageInfo"]["hasPreviousPage"])
       assert_equal("MQ==", result["data"]["rebels"]["ships"]["pageInfo"]["startCursor"])
       assert_equal("NQ==", result["data"]["rebels"]["ships"]["pageInfo"]["endCursor"])
     end
 
     it 'slices the result' do
-      result = query(query_string, "first" => 1)
+      result = star_wars_query(query_string, "first" => 1)
       assert_equal(["X-Wing"], get_names(result))
 
       # After the last result, find the next 2:
       last_cursor = get_last_cursor(result)
 
-      result = query(query_string, "after" => last_cursor, "first" => 2)
+      result = star_wars_query(query_string, "after" => last_cursor, "first" => 2)
       assert_equal(["Y-Wing", "A-Wing"], get_names(result))
 
       # After the last result, find the next 2:
       last_cursor = get_last_cursor(result)
 
-      result = query(query_string, "after" => last_cursor, "first" => 2)
+      result = star_wars_query(query_string, "after" => last_cursor, "first" => 2)
       assert_equal(["Millenium Falcon", "Home One"], get_names(result))
 
-      result = query(query_string, "before" => last_cursor, "last" => 2)
+      result = star_wars_query(query_string, "before" => last_cursor, "last" => 2)
       assert_equal(["X-Wing", "Y-Wing"], get_names(result))
     end
 
     it 'applies custom arguments' do
-      result = query(query_string, "nameIncludes" => "Wing", "first" => 2)
+      result = star_wars_query(query_string, "nameIncludes" => "Wing", "first" => 2)
       names = get_names(result)
       assert_equal(2, names.length)
 
       after = get_last_cursor(result)
-      result = query(query_string, "nameIncludes" => "Wing", "after" => after, "first" => 3)
+      result = star_wars_query(query_string, "nameIncludes" => "Wing", "after" => after, "first" => 3)
       names = get_names(result)
       assert_equal(1, names.length)
     end
 
     it 'works without first/last/after/before' do
-      result = query(query_string)
+      result = star_wars_query(query_string)
 
       assert_equal(false, result["data"]["rebels"]["ships"]["pageInfo"]["hasNextPage"])
       assert_equal(false, result["data"]["rebels"]["ships"]["pageInfo"]["hasPreviousPage"])
@@ -130,33 +130,33 @@ def get_page_info(result)
       |}
 
       it "applies to queries by `first`" do
-        result = query(query_string, "first" => 100)
+        result = star_wars_query(query_string, "first" => 100)
         assert_equal(["Yavin", "Echo Base"], get_names(result))
         assert_equal(true, get_page_info(result)["hasNextPage"])
 
         # Max page size is applied _without_ `first`, also
-        result = query(query_string)
+        result = star_wars_query(query_string)
         assert_equal(["Yavin", "Echo Base"], get_names(result))
         assert_equal(false, get_page_info(result)["hasNextPage"], "hasNextPage is false when first is not specified")
       end
 
       it "applies to queries by `last`" do
         last_cursor = "Ng=="
         second_to_last_two_names = ["Death Star", "Shield Generator"]
-        result = query(query_string, "last" => 100, "before" => last_cursor)
+        result = star_wars_query(query_string, "last" => 100, "before" => last_cursor)
         assert_equal(second_to_last_two_names, get_names(result))
         assert_equal(true, get_page_info(result)["hasPreviousPage"])
 
-        result = query(query_string, "before" => last_cursor)
+        result = star_wars_query(query_string, "before" => last_cursor)
         assert_equal(second_to_last_two_names, get_names(result))
         assert_equal(false, get_page_info(result)["hasPreviousPage"], "hasPreviousPage is false when last is not specified")
 
         third_cursor = "Mw=="
         first_and_second_names = ["Yavin", "Echo Base"]
-        result = query(query_string, "last" => 100, "before" => third_cursor)
+        result = star_wars_query(query_string, "last" => 100, "before" => third_cursor)
         assert_equal(first_and_second_names, get_names(result))
 
-        result = query(query_string, "before" => third_cursor)
+        result = star_wars_query(query_string, "before" => third_cursor)
         assert_equal(first_and_second_names, get_names(result))
       end
     end

spec/graphql/relay/connection_type_spec.rb

@@ -24,7 +24,7 @@
       |}
 
       it "uses the custom edge and custom connection" do
-        result = query(query_string)
+        result = star_wars_query(query_string)
         bases = result["data"]["rebels"]["basesWithCustomEdge"]
         assert_equal 300, bases["totalCountTimes100"]
         assert_equal 'basesWithCustomEdge', bases["fieldName"]

spec/graphql/relay/global_node_identification_spec.rb

@@ -5,7 +5,7 @@
   describe 'NodeField' do
     it 'finds objects by id' do
       global_id = node_identification.to_global_id("Faction", "1")
-      result = query(%|{
+      result = star_wars_query(%|{
         node(id: "#{global_id}") {
           id,
           ... on Faction {
@@ -107,15 +107,15 @@
 
       describe "generating IDs" do
         it "Applies custom-defined ID generation" do
-          result = query(%| { largestBase { id } }|)
+          result = star_wars_query(%| { largestBase { id } }|)
           generated_id = result["data"]["largestBase"]["id"]
           assert_equal "Base/3", generated_id
         end
       end
 
       describe "fetching by ID" do
         it "Deconstructs the ID by the custom proc" do
-          result = query(%| { node(id: "Base/1") { ... on Base { name } } }|)
+          result = star_wars_query(%| { node(id: "Base/1") { ... on Base { name } } }|)
           base_name = result["data"]["node"]["name"]
           assert_equal "Yavin", base_name
         end

spec/graphql/relay/mutation_spec.rb

@@ -26,7 +26,7 @@
   end
 
   it "returns the result & clientMutationId" do
-    result = query(query_string, "clientMutationId" => "1234")
+    result = star_wars_query(query_string, "clientMutationId" => "1234")
     expected = {"data" => {
       "introduceShip" => {
         "clientMutationId" => "1234",
@@ -43,7 +43,7 @@
   end
 
   it "doesn't require a clientMutationId to perform mutations" do
-    result = query(query_string)
+    result = star_wars_query(query_string)
     new_ship_name = result["data"]["introduceShip"]["shipEdge"]["node"]["name"]
     assert_equal("Bagel", new_ship_name)
   end