Merge pull request #12 from ElvinEfendi/allow-new-enum-values-config

Allow new enum values config

Author: rmosolgo

lib/graphql/client.rb

@@ -91,7 +91,7 @@ def self.dump_schema(schema, io = nil, context: {})
       result
     end
 
-    def initialize(schema:, execute: nil, enforce_collocated_callers: false)
+    def initialize(schema:, execute: nil, enforce_collocated_callers: false, raise_on_unknown_enum_value: true)
       @schema = self.class.load_schema(schema)
       @execute = execute
       @document = GraphQL::Language::Nodes::Document.new(definitions: [])
@@ -101,7 +101,7 @@ def initialize(schema:, execute: nil, enforce_collocated_callers: false)
       if schema.is_a?(Class)
         @possible_types = schema.possible_types
       end
-      @types = Schema.generate(@schema)
+      @types = Schema.generate(@schema, raise_on_unknown_enum_value: raise_on_unknown_enum_value)
     end
 
     # A cache of the schema's merged possible types

lib/graphql/client/schema.rb

@@ -43,7 +43,7 @@ def get_class(type_name)
         def set_class(type_name, klass)
           class_name = normalize_type_name(type_name)
 
-          if constants.include?(class_name.to_sym)
+          if const_defined?(class_name, false)
             raise ArgumentError,
               "Can't define #{class_name} to represent type #{type_name} " \
               "because it's already defined"
@@ -66,9 +66,10 @@ def normalize_type_name(type_name)
         end
       end
 
-      def self.generate(schema)
+      def self.generate(schema, raise_on_unknown_enum_value: true)
         mod = Module.new
         mod.extend ClassMethods
+        mod.define_singleton_method(:raise_on_unknown_enum_value) { raise_on_unknown_enum_value }
 
         cache = {}
         schema.types.each do |name, type|

lib/graphql/client/schema/enum_type.rb

@@ -16,6 +16,10 @@ def initialize(obj, enum_value, enum)
             @enum = enum
           end
 
+          def unknown_enum_value?
+            false
+          end
+
           def respond_to_missing?(method_name, include_private = false)
             if method_name[-1] == "?" && @enum.include?(method_name[0..-2])
               true
@@ -37,6 +41,12 @@ def method_missing(method_name, *args)
           end
         end
 
+        class UnexpectedEnumValue < String
+          def unknown_enum_value?
+            true
+          end
+        end
+
         # Internal: Construct enum wrapper from another GraphQL::EnumType.
         #
         # type - GraphQL::EnumType instance
@@ -78,8 +88,13 @@ def [](value)
         def cast(value, _errors = nil)
           case value
           when String
-            raise Error, "unexpected enum value #{value}" unless @values.key?(value)
-            @values[value]
+            if @values.key?(value)
+              @values[value]
+            elsif schema_module.raise_on_unknown_enum_value
+              raise Error, "unexpected enum value #{value}"
+            else
+              UnexpectedEnumValue.new(value).freeze
+            end
           when NilClass
             value
           else

test/test_schema.rb

@@ -73,7 +73,7 @@ def self.resolve_type(_type, _obj, _ctx)
     end
   end
 
-  Types = GraphQL::Client::Schema.generate(Schema)
+  Types = GraphQL::Client::Schema.generate(Schema, raise_on_unknown_enum_value: true)
 
   def test_query_object_class
     assert_equal QueryType, Types::Query.type
@@ -149,6 +149,34 @@ def test_plan_enum_constants
     refute Types::Plan::SMALL.free?
     assert Types::Plan::SMALL.small?
     refute Types::Plan::SMALL.large?
+
+    assert_raises GraphQL::Client::Error do
+      Types::Plan.cast("unknown_value")
+    end
+  end
+
+  def test_unknown_enum_values
+    size = Class.new(GraphQL::Schema::Enum) do
+      graphql_name "Size"
+      value "SMALL"
+      value "MEDIUM"
+      value "LARGE"
+    end
+
+    query_type = Class.new(GraphQL::Schema::Object) do
+      graphql_name "Query"
+      field :size, size, null: false
+    end
+
+    schema = Class.new(GraphQL::Schema) do
+      query query_type
+    end
+
+    types = GraphQL::Client::Schema.generate(schema, raise_on_unknown_enum_value: false)
+
+    assert_equal "unknown_value", types::Size.cast("unknown_value")
+    assert types::Size.cast("unknown_value").unknown_enum_value?
+    refute types::Size.cast("SMALL").unknown_enum_value?
   end
 
   def test_to_non_null_type