graphql-client 0.9.0 → 0.10.0

data/lib/graphql/client/schema/enum_type.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "graphql/client/error"
+require "graphql/client/schema/base_type"
+
+module GraphQL
+  class Client
+    module Schema
+      class EnumType < Module
+        include BaseType
+
+        # Internal: Construct enum wrapper from another GraphQL::EnumType.
+        #
+        # type - GraphQL::EnumType instance
+        def initialize(type)
+          unless type.is_a?(GraphQL::EnumType)
+            raise "expected type to be a GraphQL::EnumType, but was #{type.class}"
+          end
+
+          @type = type
+
+          all_values = type.values.keys
+
+          all_values.each do |value|
+            str = value.dup
+            all_values.each do |v|
+              str.define_singleton_method("#{v.downcase}?") { false }
+            end
+            str.define_singleton_method("#{value.downcase}?") { true }
+            str.freeze
+            const_set(value, str)
+          end
+        end
+
+        def define_class(definition, irep_node)
+          self
+        end
+
+        # Internal: Cast JSON value to wrapped value.
+        #
+        # values - JSON value
+        # errors - Errors instance
+        #
+        # Returns String or nil.
+        def cast(value, _errors = nil)
+          case value
+          when String, NilClass
+            value
+          else
+            raise InvariantError, "expected value to be a String, but was #{value.class}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/client/schema/include_directive.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "graphql/client/schema/base_type"
+
+module GraphQL
+  class Client
+    module Schema
+      class IncludeDirective
+        include BaseType
+
+        # Internal: Construct list wrapper from other BaseType.
+        #
+        # of_klass - BaseType instance
+        def initialize(of_klass)
+          unless of_klass.is_a?(BaseType)
+            raise TypeError, "expected #{of_klass.inspect} to be a #{BaseType}"
+          end
+
+          @of_klass = of_klass
+        end
+
+        # Internal: Get wrapped klass.
+        #
+        # Returns BaseType instance.
+        attr_reader :of_klass
+
+        # Internal: Cast JSON value to wrapped value.
+        #
+        # values - JSON value
+        # errors - Errors instance
+        #
+        # Returns List instance or nil.
+        def cast(value, errors)
+          case value
+          when NilClass
+            nil
+          else
+            of_klass.cast(value, errors)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/client/schema/interface_type.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "graphql/client/schema/possible_types"
+
+module GraphQL
+  class Client
+    module Schema
+      class InterfaceType < Module
+        include BaseType
+
+        def initialize(type)
+          unless type.is_a?(GraphQL::InterfaceType)
+            raise "expected type to be a GraphQL::InterfaceType, but was #{type.class}"
+          end
+
+          @type = type
+        end
+
+        def new(types)
+          PossibleTypes.new(type, types)
+        end
+
+        def define_class(definition, irep_node)
+          new(irep_node.typed_children.keys.map { |ctype|
+            schema_module.const_get(ctype.name).define_class(definition, irep_node)
+          })
+        end
+      end
+    end
+  end
+end

data/lib/graphql/client/schema/list_type.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "graphql/client/error"
+require "graphql/client/list"
+require "graphql/client/schema/base_type"
+
+module GraphQL
+  class Client
+    module Schema
+      class ListType
+        include BaseType
+
+        # Internal: Construct list wrapper from other BaseType.
+        #
+        # of_klass - BaseType instance
+        def initialize(of_klass)
+          unless of_klass.is_a?(BaseType)
+            raise TypeError, "expected #{of_klass.inspect} to be a #{BaseType}"
+          end
+
+          @of_klass = of_klass
+        end
+
+        # Internal: Get wrapped klass.
+        #
+        # Returns BaseType instance.
+        attr_reader :of_klass
+
+        # Internal: Cast JSON value to wrapped value.
+        #
+        # values - JSON value
+        # errors - Errors instance
+        #
+        # Returns List instance or nil.
+        def cast(values, errors)
+          case values
+          when Array
+            List.new(values.each_with_index.map { |e, idx|
+              of_klass.cast(e, errors.filter_by_path(idx))
+            }, errors)
+          when NilClass
+            nil
+          else
+            raise InvariantError, "expected value to be a list, but was #{values.class}"
+          end
+        end
+
+        # Internal: Get list wrapper of this type class.
+        #
+        # Returns ListType instance.
+        def to_list_type
+          self
+        end
+      end
+    end
+  end
+end

data/lib/graphql/client/schema/non_null_type.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "graphql/client/error"
+require "graphql/client/schema/base_type"
+
+module GraphQL
+  class Client
+    module Schema
+      class NonNullType
+        include BaseType
+
+        # Internal: Construct non-nullable wrapper from other BaseType.
+        #
+        # of_klass - BaseType instance
+        def initialize(of_klass)
+          unless of_klass.is_a?(BaseType)
+            raise TypeError, "expected #{of_klass.inspect} to be a #{BaseType}"
+          end
+
+          @of_klass = of_klass
+        end
+
+        # Internal: Get wrapped klass.
+        #
+        # Returns BaseType instance.
+        attr_reader :of_klass
+
+        # Internal: Cast JSON value to wrapped value.
+        #
+        # value - JSON value
+        # errors - Errors instance
+        #
+        # Returns BaseType instance.
+        def cast(value, errors)
+          case value
+          when NilClass
+            raise InvariantError, "expected value to be non-nullable, but was nil"
+          else
+            of_klass.cast(value, errors)
+          end
+        end
+
+        # Internal: Get non-nullable wrapper of this type class.
+        #
+        # Returns NonNullType instance.
+        def to_non_null_type
+          self
+        end
+      end
+    end
+  end
+end

data/lib/graphql/client/schema/object_type.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require "active_support/inflector"
+require "graphql/client/deprecation"
+require "graphql/client/error"
+require "graphql/client/errors"
+require "graphql/client/schema/base_type"
+require "graphql/client/schema/possible_types"
+
+module GraphQL
+  class Client
+    module Schema
+      module ObjectType
+        def self.new(type, fields = {})
+          Class.new(ObjectClass) do
+            extend BaseType
+            extend ObjectType
+
+            define_singleton_method(:type) { type }
+            define_singleton_method(:fields) { fields }
+          end
+        end
+
+        def define_class(definition, irep_node)
+          fields = irep_node.typed_children[type].inject({}) { |h, (field_name, field_irep_node)|
+            if definition.indexes[:definitions][field_irep_node.ast_node] == definition.definition_node
+              h[field_name.to_sym] = schema_module.define_class(definition, field_irep_node, field_irep_node.definition.type)
+            end
+            h
+          }
+
+          Class.new(self) do
+            define_fields(fields)
+
+            if definition.client.enforce_collocated_callers
+              Client.enforce_collocated_callers(self, fields.keys, definition.source_location[0])
+            end
+
+            class << self
+              attr_reader :source_definition
+              attr_reader :_spreads
+            end
+
+            @source_definition = definition
+            @_spreads = definition.indexes[:spreads][irep_node.ast_node]
+          end
+        end
+
+        def define_fields(fields)
+          fields.each { |name, type| define_field(name, type) }
+        end
+
+        def define_field(name, type)
+          name = name.to_s
+          method_name = ActiveSupport::Inflector.underscore(name)
+
+          define_method(method_name) do
+            @casted_data.fetch(name) do
+              @casted_data[name] = type.cast(@data[name], @errors.filter_by_path(name))
+            end
+          end
+
+          define_method("#{method_name}?") do
+            @data[name] ? true : false
+          end
+
+          if name != method_name
+            define_method(name) do
+              @casted_data.fetch(name) do
+                @casted_data[name] = type.cast(@data[name], @errors.filter_by_path(name))
+              end
+            end
+            Deprecation.deprecate_methods(self, name => "Use ##{method_name} instead")
+          end
+        end
+
+        def cast(value, errors)
+          case value
+          when Hash
+            new(value, errors)
+          when NilClass
+            nil
+          else
+            raise InvariantError, "expected value to be a Hash, but was #{value.class}"
+          end
+        end
+      end
+
+      class ObjectClass
+        def initialize(data = {}, errors = Errors.new)
+          @data = data
+          @casted_data = {}
+          @errors = errors
+        end
+
+        # Public: Returns the raw response data
+        #
+        # Returns Hash
+        def to_h
+          @data
+        end
+
+        # Public: Return errors associated with data.
+        #
+        # Returns Errors collection.
+        attr_reader :errors
+
+        def method_missing(*args)
+          super
+        rescue NoMethodError => e
+          type = self.class.type
+
+          field = type.all_fields.find do |f|
+            f.name == e.name.to_s || ActiveSupport::Inflector.underscore(f.name) == e.name.to_s
+          end
+
+          unless field
+            raise UnimplementedFieldError, "undefined field `#{e.name}' on #{type} type. https://git.io/v1y3m"
+          end
+
+          if @data.key?(field.name)
+            error_class = ImplicitlyFetchedFieldError
+            message = "implicitly fetched field `#{field.name}' on #{type} type. https://git.io/v1yGL"
+          else
+            error_class = UnfetchedFieldError
+            message = "unfetched field `#{field.name}' on #{type} type. https://git.io/v1y3U"
+          end
+
+          raise error_class, message
+        end
+
+        def inspect
+          parent = self.class.ancestors.select { |m| m.is_a?(ObjectType) }.last
+
+          ivars = @data.map { |key, value|
+            if value.is_a?(Hash) || value.is_a?(Array)
+              "#{key}=..."
+            else
+              "#{key}=#{value.inspect}"
+            end
+          }
+
+          buf = "#<#{parent.name}".dup
+          buf << " " << ivars.join(" ") if ivars.any?
+          buf << ">"
+          buf
+        end
+
+        def typename
+          Deprecation.deprecation_warning("typename", "Use #class.type.name instead")
+          self.class.type.name
+        end
+
+        def type_of?(*types)
+          Deprecation.deprecation_warning("type_of?", "Use #is_a? instead")
+          names = ([self.class.type] + self.class.ancestors.select { |m| m.is_a?(InterfaceType) || m.is_a?(UnionType) }.map(&:type)).map(&:name)
+          types.any? { |type| names.include?(type.to_s) }
+        end
+      end
+    end
+  end
+end

data/lib/graphql/client/schema/possible_types.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "graphql/client/error"
+require "graphql/client/schema/base_type"
+require "graphql/client/schema/object_type"
+
+module GraphQL
+  class Client
+    module Schema
+      class PossibleTypes
+        include BaseType
+
+        def initialize(type, types)
+          @type = type
+
+          unless types.is_a?(Enumerable)
+            raise TypeError, "expected types to be Enumerable, but was #{types.class}"
+          end
+
+          @possible_types = {}
+          types.each do |klass|
+            unless klass.is_a?(ObjectType)
+              raise TypeError, "expected type to be #{ObjectType}, but was #{type.class}"
+            end
+            @possible_types[klass.type.name] = klass
+          end
+        end
+
+        attr_reader :possible_types
+
+        # Internal: Cast JSON value to wrapped value.
+        #
+        # value - JSON value
+        # errors - Errors instance
+        #
+        # Returns BaseType instance.
+        def cast(value, errors)
+          case value
+          when Hash
+            typename = value["__typename"]
+            if type = possible_types[typename]
+              type.cast(value, errors)
+            else
+              raise InvariantError, "expected value to be one of (#{possible_types.keys.join(", ")}), but was #{typename}"
+            end
+          when NilClass
+            nil
+          else
+            raise InvariantError, "expected value to be a Hash, but was #{value.class}"
+          end
+        end
+      end
+    end
+  end
+end