graphql 1.0.0 → 1.1.0

data/lib/graphql/scalar_type.rb

@@ -41,7 +41,7 @@ module GraphQL
       self.coerce_result = proc
     end
 
-    def validate_non_null_input(value)
+    def validate_non_null_input(value, warden)
       result = Query::InputValidationResult.new
       if coerce_non_null_input(value).nil?
         result.add_problem("Could not coerce value #{JSON.generate(value, quirks_mode: true)} to #{name}")

data/lib/graphql/schema.rb

@@ -1,5 +1,6 @@
 require "graphql/schema/catchall_middleware"
 require "graphql/schema/invalid_type_error"
+require "graphql/schema/instrumented_field_map"
 require "graphql/schema/middleware_chain"
 require "graphql/schema/possible_types"
 require "graphql/schema/rescue_middleware"
@@ -9,6 +10,8 @@ require "graphql/schema/type_expression"
 require "graphql/schema/type_map"
 require "graphql/schema/unique_within_type"
 require "graphql/schema/validation"
+require "graphql/schema/warden"
+require "graphql/schema/build_from_definition"
 
 module GraphQL
   # A GraphQL schema which may be queried with {GraphQL::Query}.
@@ -43,6 +46,8 @@ module GraphQL
   #   end
   #
   class Schema
+    include BuildFromDefinition
+
     include GraphQL::Define::InstanceDefinable
     accepts_definitions \
       :query, :mutation, :subscription,
@@ -50,6 +55,8 @@ module GraphQL
       :max_depth, :max_complexity,
       :orphan_types, :resolve_type,
       :object_from_id, :id_from_object,
+      directives: ->(schema, directives) { schema.directives = directives.reduce({}) { |m, d| m[d.name] = d; m  }},
+      instrument: -> (schema, type, instrumenter) { schema.instrumenters[type] << instrumenter },
       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)}
@@ -58,13 +65,14 @@ module GraphQL
       :query, :mutation, :subscription,
       :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
       :max_depth, :max_complexity,
-      :orphan_types,
-      :query_analyzers, :middleware
+      :orphan_types, :directives,
+      :query_analyzers, :middleware, :instrumenters
 
+    BUILT_IN_TYPES = Hash[[INT_TYPE, STRING_TYPE, FLOAT_TYPE, BOOLEAN_TYPE, ID_TYPE].map{ |type| [type.name, type] }]
     DIRECTIVES = [GraphQL::Directive::IncludeDirective, GraphQL::Directive::SkipDirective, GraphQL::Directive::DeprecatedDirective]
     DYNAMIC_FIELDS = ["__type", "__typename", "__schema"]
 
-    attr_reader :directives, :static_validator, :object_from_id_proc, :id_from_object_proc, :resolve_type_proc
+    attr_reader :static_validator, :object_from_id_proc, :id_from_object_proc, :resolve_type_proc
 
     # @!attribute [r] middleware
     #   @return [Array<#call>] Middlewares suitable for MiddlewareChain, applied to fields during execution
@@ -83,6 +91,7 @@ module GraphQL
       @resolve_type_proc = nil
       @object_from_id_proc = nil
       @id_from_object_proc = nil
+      @instrumenters = Hash.new { |h, k| h[k] = [] }
       # Default to the built-in execution strategy:
       @query_execution_strategy = GraphQL::Query::SerialExecution
       @mutation_execution_strategy = GraphQL::Query::SerialExecution
@@ -101,21 +110,33 @@ module GraphQL
 
     def define(**kwargs, &block)
       super
-      types
+      all_types = orphan_types + [query, mutation, subscription, GraphQL::Introspection::SchemaType]
+      @types = GraphQL::Schema::ReduceTypes.reduce(all_types.compact)
+
+      @instrumented_field_map = InstrumentedFieldMap.new(self)
+      field_instrumenters = @instrumenters[:field]
+      types.each do |type_name, type|
+        if type.kind.fields?
+          type.all_fields.each do |field_defn|
+
+            instrumented_field_defn = field_instrumenters.reduce(field_defn) do |defn, inst|
+              inst.instrument(type, defn)
+            end
+
+            @instrumented_field_map.set(type.name, field_defn.name, instrumented_field_defn)
+          end
+        end
+      end
       # Assert that all necessary configs are present:
       validation_error = Validation.validate(self)
       validation_error && raise(NotImplementedError, validation_error)
       nil
     end
 
+
+    # @see [GraphQL::Schema::Warden] Restricted access to members of a schema
     # @return [GraphQL::Schema::TypeMap] `{ name => type }` pairs of types in this schema
-    def types
-      @types ||= begin
-        ensure_defined
-        all_types = orphan_types + [query, mutation, subscription, GraphQL::Introspection::SchemaType]
-        GraphQL::Schema::ReduceTypes.reduce(all_types.compact)
-      end
-    end
+    attr_reader :types
 
     # Execute a query on itself.
     # See {Query#initialize} for arguments.
@@ -127,9 +148,11 @@ module GraphQL
 
     # Resolve field named `field_name` for type `parent_type`.
     # Handles dynamic fields `__typename`, `__type` and `__schema`, too
+    # @see [GraphQL::Schema::Warden] Restricted access to members of a schema
+    # @return [GraphQL::Field, nil] The field named `field_name` on `parent_type`
     def get_field(parent_type, field_name)
       ensure_defined
-      defined_field = parent_type.get_field(field_name)
+      defined_field = @instrumented_field_map.get(parent_type.name, field_name)
       if defined_field
         defined_field
       elsif field_name == "__typename"
@@ -137,7 +160,7 @@ module GraphQL
       elsif field_name == "__schema" && parent_type == query
         GraphQL::Introspection::SchemaField.create(self)
       elsif field_name == "__type" && parent_type == query
-        GraphQL::Introspection::TypeByNameField.create(self.types)
+        GraphQL::Introspection::TypeByNameField.create(self)
       else
         nil
       end
@@ -145,16 +168,16 @@ module GraphQL
 
     def type_from_ast(ast_node)
       ensure_defined
-      GraphQL::Schema::TypeExpression.build_type(self, ast_node)
+      GraphQL::Schema::TypeExpression.build_type(self.types, ast_node)
     end
 
-    # TODO: when `resolve_type` is schema level, can this be removed?
+    # @see [GraphQL::Schema::Warden] Restricted access to members of a schema
     # @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)
+      @possible_types ||= GraphQL::Schema::PossibleTypes.new(self)
+      @possible_types.possible_types(type_defn)
     end
 
     def root_type_for_operation(operation)
@@ -184,7 +207,8 @@ module GraphQL
     end
 
     # Determine the GraphQL type for a given object.
-    # This is required for unions and interfaces (include Relay's node interface)
+    # This is required for unions and interfaces (including Relay's `Node` interface)
+    # @see [GraphQL::Schema::Warden] Restricted access to members of a schema
     # @param object [Any] An application object which GraphQL is currently resolving on
     # @param ctx [GraphQL::Query::Context] The context for the current query
     # @return [GraphQL::ObjectType] The type for exposing `object` in GraphQL
@@ -250,6 +274,13 @@ module GraphQL
       @id_from_object_proc = new_proc
     end
 
+    # Create schema with the result of an introspection query.
+    # @param introspection_result [Hash] A response from {GraphQL::Introspection::INTROSPECTION_QUERY}
+    # @return [GraphQL::Schema] the schema described by `input`
+    def self.from_introspection(introspection_result)
+      GraphQL::Schema::Loader.load(introspection_result)
+    end
+
     private
 
     # Lazily create a middleware and add it to the schema

data/lib/graphql/schema/build_from_definition.rb

@@ -0,0 +1,248 @@
+module GraphQL
+  class Schema
+    module BuildFromDefinition
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      class InvalidDocumentError < Error; end;
+
+      module ClassMethods
+        # Create schema from an IDL schema.
+        # @param definition_string String A schema definition string
+        # @return [GraphQL::Schema] the schema described by `document`
+        def from_definition(definition_string)
+          document = GraphQL::parse(definition_string)
+          Builder.build(document)
+        end
+      end
+
+      module Builder
+        extend self
+
+        def build(document)
+          raise InvalidDocumentError.new('Must provide a document ast.') if !document || !document.is_a?(GraphQL::Language::Nodes::Document)
+
+          schema_definition = nil
+          types = {}
+          types.merge!(GraphQL::Schema::BUILT_IN_TYPES)
+          directives = {}
+          type_resolver = -> (type) { -> { resolve_type(types, type) } }
+
+          document.definitions.each do |definition|
+            case definition
+            when GraphQL::Language::Nodes::SchemaDefinition
+              raise InvalidDocumentError.new('Must provide only one schema definition.') if schema_definition
+              schema_definition = definition
+            when GraphQL::Language::Nodes::EnumTypeDefinition
+              types[definition.name] = build_enum_type(definition, type_resolver)
+            when GraphQL::Language::Nodes::ObjectTypeDefinition
+              types[definition.name] = build_object_type(definition, type_resolver)
+            when GraphQL::Language::Nodes::InterfaceTypeDefinition
+              types[definition.name] = build_interface_type(definition, type_resolver)
+            when GraphQL::Language::Nodes::UnionTypeDefinition
+              types[definition.name] = build_union_type(definition, type_resolver)
+            when GraphQL::Language::Nodes::ScalarTypeDefinition
+              types[definition.name] = build_scalar_type(definition, type_resolver)
+            when GraphQL::Language::Nodes::InputObjectTypeDefinition
+              types[definition.name] = build_input_object_type(definition, type_resolver)
+            when GraphQL::Language::Nodes::DirectiveDefinition
+              directives[definition.name] = build_directive(definition, type_resolver)
+            end
+          end
+
+          GraphQL::Schema::DIRECTIVES.each do |built_in_directive|
+            directives[built_in_directive.name] = built_in_directive unless directives[built_in_directive.name]
+          end
+
+          if schema_definition
+            if schema_definition.query
+              raise InvalidDocumentError.new("Specified query type \"#{schema_definition.query}\" not found in document.") unless types[schema_definition.query]
+              query_root_type = types[schema_definition.query]
+            end
+
+            if schema_definition.mutation
+              raise InvalidDocumentError.new("Specified mutation type \"#{schema_definition.mutation}\" not found in document.") unless types[schema_definition.mutation]
+              mutation_root_type = types[schema_definition.mutation]
+            end
+
+            if schema_definition.subscription
+              raise InvalidDocumentError.new("Specified subscription type \"#{schema_definition.subscription}\" not found in document.") unless types[schema_definition.subscription]
+              subscription_root_type = types[schema_definition.subscription]
+            end
+          else
+            query_root_type = types['Query']
+            mutation_root_type = types['Mutation']
+            subscription_root_type = types['Subscription']
+          end
+
+          raise InvalidDocumentError.new('Must provide schema definition with query type or a type named Query.') unless query_root_type
+
+          Schema.define do
+            query query_root_type
+            mutation mutation_root_type
+            subscription subscription_root_type
+            orphan_types types.values
+            resolve_type NullResolveType
+
+            directives directives.values
+          end
+        end
+
+        NullResolveType = -> (obj, ctx) {
+          raise(NotImplementedError, "Generated Schema cannot use Interface or Union types for execution.")
+        }
+
+        def build_enum_type(enum_type_definition, type_resolver)
+          GraphQL::EnumType.define(
+            name: enum_type_definition.name,
+            description: enum_type_definition.description,
+            values: enum_type_definition.values.map do |enum_value_definition|
+              EnumType::EnumValue.define(
+                name: enum_value_definition.name,
+                value: enum_value_definition.name,
+                deprecation_reason: build_deprecation_reason(enum_value_definition.directives),
+                description: enum_value_definition.description,
+              )
+            end
+          )
+        end
+
+        def build_deprecation_reason(directives)
+          deprecated_directive = directives.find{ |d| d.name == 'deprecated' }
+          return unless deprecated_directive
+
+          reason = deprecated_directive.arguments.find{ |a| a.name == 'reason' }
+          return GraphQL::Directive::DEFAULT_DEPRECATION_REASON unless reason
+
+          reason.value
+        end
+
+        def build_scalar_type(scalar_type_definition, type_resolver)
+          GraphQL::ScalarType.define(
+            name: scalar_type_definition.name,
+            description: scalar_type_definition.description,
+          )
+        end
+
+        def build_union_type(union_type_definition, type_resolver)
+          GraphQL::UnionType.define(
+            name: union_type_definition.name,
+            description: union_type_definition.description,
+            possible_types: union_type_definition.types.map{ |type_name| type_resolver.call(type_name) },
+          )
+        end
+
+        def build_object_type(object_type_definition, type_resolver)
+          GraphQL::ObjectType.define(
+            name: object_type_definition.name,
+            description: object_type_definition.description,
+            fields: Hash[build_fields(object_type_definition.fields, type_resolver)],
+            interfaces: object_type_definition.interfaces.map{ |interface_name| type_resolver.call(interface_name) },
+          )
+        end
+
+        def build_input_object_type(input_object_type_definition, type_resolver)
+          GraphQL::InputObjectType.define(
+            name: input_object_type_definition.name,
+            description: input_object_type_definition.description,
+            arguments: Hash[build_input_arguments(input_object_type_definition, type_resolver)],
+          )
+        end
+
+        def build_input_arguments(input_object_type_definition, type_resolver)
+          input_object_type_definition.fields.map do |input_argument|
+            default_value = case input_argument.default_value
+            when GraphQL::Language::Nodes::Enum
+              input_argument.default_value.name
+            else
+              input_argument.default_value
+            end
+
+            [
+              input_argument.name,
+              GraphQL::Argument.define(
+                name: input_argument.name,
+                type: type_resolver.call(input_argument.type),
+                description: input_argument.description,
+                default_value: default_value,
+              )
+            ]
+          end
+        end
+
+        def build_directive(directive_definition, type_resolver)
+          GraphQL::Directive.define(
+            name: directive_definition.name,
+            description: directive_definition.description,
+            arguments: Hash[build_directive_arguments(directive_definition, type_resolver)],
+            locations: directive_definition.locations.map(&:to_sym),
+          )
+        end
+
+        def build_directive_arguments(directive_definition, type_resolver)
+          directive_definition.arguments.map do |directive_argument|
+            [
+              directive_argument.name,
+              GraphQL::Argument.define(
+                name: directive_argument.name,
+                type: type_resolver.call(directive_argument.type),
+                description: directive_argument.description,
+                default_value: directive_argument.default_value,
+              )
+            ]
+          end
+        end
+
+        def build_interface_type(interface_type_definition, type_resolver)
+          GraphQL::InterfaceType.define(
+            name: interface_type_definition.name,
+            description: interface_type_definition.description,
+            fields: Hash[build_fields(interface_type_definition.fields, type_resolver)],
+          )
+        end
+
+        def build_fields(field_definitions, type_resolver)
+          field_definitions.map do |field_definition|
+            field_arguments = Hash[field_definition.arguments.map do |argument|
+              default_value = case argument.default_value
+              when GraphQL::Language::Nodes::Enum
+                argument.default_value.name
+              else
+                argument.default_value
+              end
+
+              arg = GraphQL::Argument.define(
+                name: argument.name,
+                description: argument.description,
+                type: type_resolver.call(argument.type),
+                default_value: default_value,
+              )
+
+              [argument.name, arg]
+            end]
+
+            [
+              field_definition.name,
+              GraphQL::Field.define(
+                name: field_definition.name,
+                description: field_definition.description,
+                type: type_resolver.call(field_definition.type),
+                arguments: field_arguments,
+                deprecation_reason: build_deprecation_reason(field_definition.directives),
+              )
+            ]
+          end
+        end
+
+        def resolve_type(types, ast_node)
+          type = GraphQL::Schema::TypeExpression.build_type(types, ast_node)
+          raise InvalidDocumentError.new("Type \"#{ast_node.name}\" not found in document.") unless type
+          type
+        end
+      end
+
+      private_constant :Builder
+    end
+  end
+end

data/lib/graphql/schema/instrumented_field_map.rb

@@ -0,0 +1,23 @@
+module GraphQL
+  class Schema
+    # A two-level map with fields as the last values.
+    # The first level is type names, which point to a second map.
+    # The second level is field names, which point to fields.
+    #
+    # The catch is, the fields in this map _may_ have been modified by being instrumented.
+    class InstrumentedFieldMap
+      def initialize(schema)
+        @storage = Hash.new { |h, k| h[k] = {} }
+      end
+
+      def set(type_name, field_name, field)
+        @storage[type_name][field_name] = field
+      end
+
+      def get(type_name, field_name)
+        type = @storage[type_name]
+        type && type[field_name]
+      end
+    end
+  end
+end

data/lib/graphql/schema/loader.rb

@@ -10,6 +10,7 @@ module GraphQL
       # Create schema with the result of an introspection query.
       # @param introspection_result [Hash] A response from {GraphQL::Introspection::INTROSPECTION_QUERY}
       # @return [GraphQL::Schema] the schema described by `input`
+      # @deprecated Use {GraphQL::Schema.from_introspection} instead
       def load(introspection_result)
         schema = introspection_result.fetch("data").fetch("__schema")
 
@@ -109,17 +110,9 @@ module GraphQL
               default_value: type["defaultValue"] ? JSON.parse(type["defaultValue"], quirks_mode: true) : nil
             )
           when "SCALAR"
-            case type.fetch("name")
-            when "Int"
-              INT_TYPE
-            when "String"
-              STRING_TYPE
-            when "Float"
-              FLOAT_TYPE
-            when "Boolean"
-              BOOLEAN_TYPE
-            when "ID"
-              ID_TYPE
+            type_name = type.fetch("name")
+            if GraphQL::Schema::BUILT_IN_TYPES[type_name]
+              GraphQL::Schema::BUILT_IN_TYPES[type_name]
             else
               ScalarType.define(
                 name: type["name"],