graphql 1.12.12 → 2.4.8

data/lib/graphql/query/variables.rb

@@ -14,41 +14,37 @@ module GraphQL
         schema = ctx.schema
         @context = ctx
 
-        @provided_variables = GraphQL::Argument.deep_stringify(provided_variables)
+        @provided_variables = deep_stringify(provided_variables)
         @errors = []
         @storage = ast_variables.each_with_object({}) do |ast_variable, memo|
+          if schema.validate_max_errors && schema.validate_max_errors <= @errors.count
+            add_max_errors_reached_message
+            break
+          end
           # Find the right value for this variable:
           # - First, use the value provided at runtime
           # - Then, fall back to the default value from the query string
           # If it's still nil, raise an error if it's required.
           variable_type = schema.type_from_ast(ast_variable.type, context: ctx)
-          if variable_type.nil?
+          if variable_type.nil? || !variable_type.unwrap.kind.input?
             # Pass -- it will get handled by a validator
           else
             variable_name = ast_variable.name
             default_value = ast_variable.default_value
             provided_value = @provided_variables[variable_name]
             value_was_provided =  @provided_variables.key?(variable_name)
+            max_errors = schema.validate_max_errors - @errors.count if schema.validate_max_errors
             begin
-              validation_result = variable_type.validate_input(provided_value, ctx)
+              validation_result = variable_type.validate_input(provided_value, ctx, max_errors: max_errors)
               if validation_result.valid?
                 if value_was_provided
                   # Add the variable if a value was provided
-                  memo[variable_name] = if ctx.interpreter?
-                    provided_value
-                  elsif provided_value.nil?
+                  memo[variable_name] = provided_value
+                elsif default_value != nil
+                  memo[variable_name] = if default_value.is_a?(Language::Nodes::NullValue)
                     nil
                   else
-                    schema.error_handler.with_error_handling(context) do
-                      variable_type.coerce_input(provided_value, ctx)
-                    end
-                  end
-                elsif default_value != nil
-                  memo[variable_name] = if ctx.interpreter?
                     default_value
-                  else
-                    # Add the variable if it wasn't provided but it has a default value (including `null`)
-                    GraphQL::Query::LiteralInput.coerce(variable_type, default_value, self)
                   end
                 end
               end
@@ -57,8 +53,7 @@ module GraphQL
               # like InputValidationResults generated by validate_non_null_input but unfortunately we don't
               # have this information available in the coerce_input call chain. Note this path is the path
               # that appears under errors.extensions.problems.path and NOT the result path under errors.path.
-              validation_result = GraphQL::Query::InputValidationResult.new
-              validation_result.add_problem(ex.message)
+              validation_result = GraphQL::Query::InputValidationResult.from_problem(ex.message)
             end
 
             if !validation_result.valid?
@@ -69,6 +64,29 @@ module GraphQL
       end
 
       def_delegators :@storage, :length, :key?, :[], :fetch, :to_h
+
+      private
+
+      def deep_stringify(val)
+        case val
+        when Array
+          val.map { |v| deep_stringify(v) }
+        when Hash
+          new_val = {}
+          val.each do |k, v|
+            new_val[k.to_s] = deep_stringify(v)
+          end
+          new_val
+        else
+          val
+        end
+      end
+
+      def add_max_errors_reached_message
+        message = "Too many errors processing variables, max validation error limit reached. Execution aborted"
+        validation_result = GraphQL::Query::InputValidationResult.from_problem(message)
+        errors << GraphQL::Query::VariableValidationError.new(nil, nil, nil, validation_result, msg: message)
+      end
     end
   end
 end

data/lib/graphql/query.rb

@@ -1,24 +1,21 @@
 # frozen_string_literal: true
-require "graphql/query/arguments"
-require "graphql/query/arguments_cache"
-require "graphql/query/context"
-require "graphql/query/executor"
-require "graphql/query/fingerprint"
-require "graphql/query/literal_input"
-require "graphql/query/null_context"
-require "graphql/query/result"
-require "graphql/query/serial_execution"
-require "graphql/query/variables"
-require "graphql/query/input_validation_result"
-require "graphql/query/variable_validation_error"
-require "graphql/query/validation_pipeline"
 
 module GraphQL
   # A combination of query string and {Schema} instance which can be reduced to a {#result}.
   class Query
+    extend Autoload
     include Tracing::Traceable
     extend Forwardable
 
+    autoload :Context, "graphql/query/context"
+    autoload :Fingerprint, "graphql/query/fingerprint"
+    autoload :NullContext, "graphql/query/null_context"
+    autoload :Result, "graphql/query/result"
+    autoload :Variables, "graphql/query/variables"
+    autoload :InputValidationResult, "graphql/query/input_validation_result"
+    autoload :VariableValidationError, "graphql/query/variable_validation_error"
+    autoload :ValidationPipeline, "graphql/query/validation_pipeline"
+
     class OperationNameMissingError < GraphQL::ExecutionError
       def initialize(name)
         msg = if name.nil?
@@ -39,7 +36,30 @@ module GraphQL
     attr_accessor :operation_name
 
     # @return [Boolean] if false, static validation is skipped (execution behavior for invalid queries is undefined)
-    attr_accessor :validate
+    attr_reader :validate
+
+    # @param new_validate [Boolean] if false, static validation is skipped. This can't be reasssigned after validation.
+    def validate=(new_validate)
+      if defined?(@validation_pipeline) && @validation_pipeline && @validation_pipeline.has_validated?
+        raise ArgumentError, "Can't reassign Query#validate= after validation has run, remove this assignment."
+      else
+        @validate = new_validate
+      end
+    end
+
+    # @return [GraphQL::StaticValidation::Validator] if present, the query will validate with these rules.
+    attr_reader :static_validator
+
+    # @param new_validate [GraphQL::StaticValidation::Validator] if present, the query will validate with these rules. This can't be reasssigned after validation.
+    def static_validator=(new_validator)
+      if defined?(@validation_pipeline) && @validation_pipeline && @validation_pipeline.has_validated?
+        raise ArgumentError, "Can't reassign Query#static_validator= after validation has run, remove this assignment."
+      elsif !new_validator.is_a?(GraphQL::StaticValidation::Validator)
+        raise ArgumentError, "Expected a `GraphQL::StaticValidation::Validator` instance."
+      else
+        @static_validator = new_validator
+      end
+    end
 
     attr_writer :query_string
 
@@ -77,30 +97,46 @@ module GraphQL
     # @param root_value [Object] the object used to resolve fields on the root type
     # @param max_depth [Numeric] the maximum number of nested selections allowed for this query (falls back to schema-level value)
     # @param max_complexity [Numeric] the maximum field complexity for this query (falls back to schema-level value)
-    # @param except [<#call(schema_member, context)>] If provided, objects will be hidden from the schema when `.call(schema_member, context)` returns truthy
-    # @param only [<#call(schema_member, context)>] If provided, objects will be hidden from the schema when `.call(schema_member, context)` returns false
-    def initialize(schema, query_string = nil, query: nil, document: nil, context: nil, variables: nil, validate: true, subscription_topic: nil, operation_name: nil, root_value: nil, max_depth: schema.max_depth, max_complexity: schema.max_complexity, except: nil, only: nil, warden: nil)
+    # @param visibility_profile [Symbol]
+    def initialize(schema, query_string = nil, query: nil, document: nil, context: nil, variables: nil, validate: true, static_validator: nil, visibility_profile: nil, subscription_topic: nil, operation_name: nil, root_value: nil, max_depth: schema.max_depth, max_complexity: schema.max_complexity, warden: nil, use_visibility_profile: nil)
       # Even if `variables: nil` is passed, use an empty hash for simpler logic
       variables ||= {}
+      @schema = schema
+      @context = schema.context_class.new(query: self, values: context)
 
-      # Use the `.graphql_definition` here which will return legacy types instead of classes
-      if schema.is_a?(Class) && !schema.interpreter?
-        schema = schema.graphql_definition
+      if use_visibility_profile.nil?
+        use_visibility_profile = warden ? false : schema.use_visibility_profile?
       end
-      @schema = schema
-      @interpreter = @schema.interpreter?
-      @filter = schema.default_filter.merge(except: except, only: only)
-      @context = schema.context_class.new(query: self, object: root_value, values: context)
-      @warden = warden
+
+      @visibility_profile = visibility_profile
+
+      if use_visibility_profile
+        @visibility_profile = @schema.visibility.profile_for(@context, visibility_profile)
+        @warden = Schema::Warden::NullWarden.new(context: @context, schema: @schema)
+      else
+        @visibility_profile = nil
+        @warden = warden
+      end
+
       @subscription_topic = subscription_topic
       @root_value = root_value
       @fragments = nil
       @operations = nil
       @validate = validate
-      @tracers = schema.tracers + (context ? context.fetch(:tracers, []) : [])
+      self.static_validator = static_validator if static_validator
+      context_tracers = (context ? context.fetch(:tracers, []) : [])
+      @tracers = schema.tracers + context_tracers
+
       # Support `ctx[:backtrace] = true` for wrapping backtraces
       if context && context[:backtrace] && !@tracers.include?(GraphQL::Backtrace::Tracer)
-        @tracers << GraphQL::Backtrace::Tracer
+        if schema.trace_class <= GraphQL::Tracing::CallLegacyTracers
+          context_tracers += [GraphQL::Backtrace::Tracer]
+          @tracers << GraphQL::Backtrace::Tracer
+        end
+      end
+
+      if !context_tracers.empty? && !(schema.trace_class <= GraphQL::Tracing::CallLegacyTracers)
+        raise ArgumentError, "context[:tracers] are not supported without `trace_with(GraphQL::Tracing::CallLegacyTracers)` in the schema configuration, please add it."
       end
 
       @analysis_errors = []
@@ -117,6 +153,10 @@ module GraphQL
         raise ArgumentError, "Query should only be provided a query string or a document, not both."
       end
 
+      if @query_string && !@query_string.is_a?(String)
+        raise ArgumentError, "Query string argument should be a String, got #{@query_string.class.name} instead."
+      end
+
       # A two-layer cache of type resolution:
       # { abstract_type => { value => resolved_type } }
       @resolved_types_cache = Hash.new do |h1, k1|
@@ -138,9 +178,12 @@ module GraphQL
       @result_values = nil
       @executed = false
 
-      # TODO add a general way to define schema-level filters
-      if @schema.respond_to?(:visible?)
-        merge_filters(only: @schema.method(:visible?))
+      @logger = if context && context[:logger] == false
+        Logger.new(IO::NULL)
+      elsif context && (l = context[:logger])
+        l
+      else
+        schema.default_logger
       end
     end
 
@@ -149,12 +192,16 @@ module GraphQL
       @query_string ||= (document ? document.to_query_string : nil)
     end
 
-    def interpreter?
-      @interpreter
-    end
+    # @return [Symbol, nil]
+    attr_reader :visibility_profile
 
     attr_accessor :multiplex
 
+    # @return [GraphQL::Tracing::Trace]
+    def current_trace
+      @current_trace ||= context[:trace] || (multiplex ? multiplex.current_trace : schema.new_trace(multiplex: multiplex, query: self))
+    end
+
     def subscription_update?
       @subscription_topic && subscription?
     end
@@ -164,9 +211,19 @@ module GraphQL
     def lookahead
       @lookahead ||= begin
         ast_node = selected_operation
-        root_type = warden.root_type_for_operation(ast_node.operation_type || "query")
-        root_type = root_type.type_class || raise("Invariant: `lookahead` only works with class-based types")
-        GraphQL::Execution::Lookahead.new(query: self, root_type: root_type, ast_nodes: [ast_node])
+        if ast_node.nil?
+          GraphQL::Execution::Lookahead::NULL_LOOKAHEAD
+        else
+          root_type = case ast_node.operation_type
+          when nil, "query"
+            types.query_root # rubocop:disable Development/ContextIsPassedCop
+          when "mutation"
+            types.mutation_root # rubocop:disable Development/ContextIsPassedCop
+          when "subscription"
+            types.subscription_root # rubocop:disable Development/ContextIsPassedCop
+          end
+          GraphQL::Execution::Lookahead.new(query: self, root_type: root_type, ast_nodes: [ast_node])
+        end
       end
     end
 
@@ -192,10 +249,10 @@ module GraphQL
     end
 
     # Get the result for this query, executing it once
-    # @return [Hash] A GraphQL response, with `"data"` and/or `"errors"` keys
+    # @return [GraphQL::Query::Result] A Hash-like GraphQL response, with `"data"` and/or `"errors"` keys
     def result
       if !@executed
-        Execution::Multiplex.run_queries(@schema, [self], context: @context)
+        Execution::Interpreter.run_all(@schema, [self], context: @context)
       end
       @result ||= Query::Result.new(query: self, values: @result_values)
     end
@@ -233,35 +290,17 @@ module GraphQL
       end
     end
 
-    def irep_selection
-      @selection ||= begin
-        if selected_operation && internal_representation
-          internal_representation.operation_definitions[selected_operation.name]
-        else
-          nil
-        end
-      end
-    end
-
     # Node-level cache for calculating arguments. Used during execution and query analysis.
     # @param ast_node [GraphQL::Language::Nodes::AbstractNode]
     # @param definition [GraphQL::Schema::Field]
     # @param parent_object [GraphQL::Schema::Object]
     # @return Hash{Symbol => Object}
     def arguments_for(ast_node, definition, parent_object: nil)
-      if interpreter?
-        arguments_cache.fetch(ast_node, definition, parent_object)
-      else
-        arguments_cache[ast_node][definition]
-      end
+      arguments_cache.fetch(ast_node, definition, parent_object)
     end
 
     def arguments_cache
-      if interpreter?
-        @arguments_cache ||= Execution::Interpreter::ArgumentsCache.new(self)
-      else
-        @arguments_cache ||= ArgumentsCache.build(self)
-      end
+      @arguments_cache ||= Execution::Interpreter::ArgumentsCache.new(self)
     end
 
     # A version of the given query string, with:
@@ -270,7 +309,7 @@ module GraphQL
     # @return [String, nil] Returns nil if the query is invalid.
     def sanitized_query_string(inline_variables: true)
       with_prepared_ast {
-        GraphQL::Language::SanitizedPrinter.new(self, inline_variables: inline_variables).sanitized_query_string
+        schema.sanitized_printer.new(self, inline_variables: inline_variables).sanitized_query_string
       }
     end
 
@@ -292,7 +331,7 @@ module GraphQL
 
     # @return [String] An opaque hash for identifying this query's given query string and selected operation
     def operation_fingerprint
-      @operation_fingerprint ||= "#{selected_operation_name || "anonymous"}/#{Fingerprint.generate(query_string)}"
+      @operation_fingerprint ||= "#{selected_operation_name || "anonymous"}/#{Fingerprint.generate(query_string || "")}"
     end
 
     # @return [String] An opaque hash for identifying this query's given a variable values (not including defaults)
@@ -304,8 +343,8 @@ module GraphQL
       with_prepared_ast { @validation_pipeline }
     end
 
-    def_delegators :validation_pipeline, :validation_errors, :internal_representation,
-                   :analyzers, :ast_analyzers, :max_depth, :max_complexity
+    def_delegators :validation_pipeline, :validation_errors,
+                   :analyzers, :ast_analyzers, :max_depth, :max_complexity, :validate_timeout_remaining
 
     attr_accessor :analysis_errors
     def valid?
@@ -316,14 +355,41 @@ module GraphQL
       with_prepared_ast { @warden }
     end
 
-    def_delegators :warden, :get_type, :get_field, :possible_types, :root_type_for_operation
+    def get_type(type_name)
+      types.type(type_name) # rubocop:disable Development/ContextIsPassedCop
+    end
+
+    def get_field(owner, field_name)
+      types.field(owner, field_name) # rubocop:disable Development/ContextIsPassedCop
+    end
+
+    def possible_types(type)
+      types.possible_types(type) # rubocop:disable Development/ContextIsPassedCop
+    end
+
+    def root_type_for_operation(op_type)
+      case op_type
+      when "query"
+        types.query_root # rubocop:disable Development/ContextIsPassedCop
+      when "mutation"
+        types.mutation_root # rubocop:disable Development/ContextIsPassedCop
+      when "subscription"
+        types.subscription_root # rubocop:disable Development/ContextIsPassedCop
+      else
+        raise ArgumentError, "unexpected root type name: #{op_type.inspect}; expected 'query', 'mutation', or 'subscription'"
+      end
+    end
+
+    def types
+      @visibility_profile || warden.visibility_profile
+    end
 
     # @param abstract_type [GraphQL::UnionType, GraphQL::InterfaceType]
     # @param value [Object] Any runtime value
     # @return [GraphQL::ObjectType, nil] The runtime type of `value` from {Schema#resolve_type}
     # @see {#possible_types} to apply filtering from `only` / `except`
-    def resolve_type(abstract_type, value = :__undefined__)
-      if value.is_a?(Symbol) && value == :__undefined__
+    def resolve_type(abstract_type, value = NOT_CONFIGURED)
+      if value.is_a?(Symbol) && value == NOT_CONFIGURED
         # Old method signature
         value = abstract_type
         abstract_type = nil
@@ -342,27 +408,29 @@ module GraphQL
       with_prepared_ast { @query }
     end
 
-    # @return [void]
-    def merge_filters(only: nil, except: nil)
-      if @prepared_ast
-        raise "Can't add filters after preparing the query"
-      else
-        @filter = @filter.merge(only: only, except: except)
-      end
-      nil
-    end
-
     def subscription?
       with_prepared_ast { @subscription }
     end
 
     # @api private
-    def with_error_handling
-      schema.error_handler.with_error_handling(context) do
-        yield
+    def handle_or_reraise(err)
+      schema.handle_or_reraise(context, err)
+    end
+
+    def after_lazy(value, &block)
+      if !defined?(@runtime_instance)
+        @runtime_instance = context.namespace(:interpreter_runtime)[:runtime]
+      end
+
+      if @runtime_instance
+        @runtime_instance.minimal_after_lazy(value, &block)
+      else
+        @schema.after_lazy(value, &block)
       end
     end
 
+    attr_reader :logger
+
     private
 
     def find_operation(operations, operation_name)
@@ -377,11 +445,11 @@ module GraphQL
 
     def prepare_ast
       @prepared_ast = true
-      @warden ||= GraphQL::Schema::Warden.new(@filter, schema: @schema, context: @context)
+      @warden ||= @schema.warden_class.new(schema: @schema, context: @context)
       parse_error = nil
       @document ||= begin
         if query_string
-          GraphQL.parse(query_string, tracer: self)
+          GraphQL.parse(query_string, trace: self.current_trace, max_tokens: @schema.max_query_string_tokens)
         end
       rescue GraphQL::ParseError => err
         parse_error = err
@@ -413,7 +481,7 @@ module GraphQL
       @mutation = false
       @subscription = false
       operation_name_error = nil
-      if @operations.any?
+      if !@operations.empty?
         @selected_operation = find_operation(@operations, @operation_name)
         if @selected_operation.nil?
           operation_name_error = GraphQL::Query::OperationNameMissingError.new(@operation_name)
@@ -430,7 +498,6 @@ module GraphQL
 
       @validation_pipeline = GraphQL::Query::ValidationPipeline.new(
         query: self,
-        validate: @validate,
         parse_error: parse_error,
         operation_name_error: operation_name_error,
         max_depth: @max_depth,

data/lib/graphql/railtie.rb

@@ -1,116 +1,22 @@
 # frozen_string_literal: true
 
 module GraphQL
+  # Support {GraphQL::Parser::Cache} and {GraphQL.eager_load!}
+  #
+  # @example Enable the parser cache with default directory
+  #
+  #   config.graphql.parser_cache = true
+  #
   class Railtie < Rails::Railtie
-    config.before_configuration do
-      # Bootsnap compile cache has similar expiration properties,
-      # so we assume that if the user has bootsnap setup it's ok
-      # to piggy back on it.
-      if ::Object.const_defined?("Bootsnap::CompileCache::ISeq") && Bootsnap::CompileCache::ISeq.cache_dir
-        Language::Parser.cache ||= Language::Cache.new(Pathname.new(Bootsnap::CompileCache::ISeq.cache_dir).join('graphql'))
-      end
-    end
-
-    rake_tasks do
-      # Defer this so that you only need the `parser` gem when you _run_ the upgrader
-      def load_upgraders
-        require_relative './upgrader/member'
-        require_relative './upgrader/schema'
-      end
-
-      namespace :graphql do
-        task :upgrade, [:dir] do |t, args|
-          unless (dir = args[:dir])
-            fail 'You have to give me a directory where your GraphQL schema and types live. ' \
-             'For example: `bin/rake graphql:upgrade[app/graphql/**/*]`'
-          end
-
-          Dir[dir].each do |file|
-            # Members (types, interfaces, etc.)
-            if file =~ /.*_(type|interface|enum|union|)\.rb$/
-              Rake::Task["graphql:upgrade:member"].execute(Struct.new(:member_file).new(file))
-            end
-          end
-
-          puts "Upgrade complete! Note that this is a best-effort approach, and may very well contain some bugs."
-          puts "Don't forget to create the base objects. For example, you could run:"
-          puts "\tbin/rake graphql:upgrade:create_base_objects[app/graphql]"
-        end
-
-        namespace :upgrade do
-          task :create_base_objects, [:base_dir] do |t, args|
-            unless (base_dir = args[:base_dir])
-              fail 'You have to give me a directory where your GraphQL types live. ' \
-                   'For example: `bin/rake graphql:upgrade:create_base_objects[app/graphql]`'
-            end
-
-            destination_file = File.join(base_dir, "types", "base_scalar.rb")
-            unless File.exists?(destination_file)
-              FileUtils.mkdir_p(File.dirname(destination_file))
-              File.open(destination_file, 'w') do |f|
-                f.puts "class Types::BaseScalar < GraphQL::Schema::Scalar\nend"
-              end
-            end
-
-            destination_file = File.join(base_dir, "types", "base_input_object.rb")
-            unless File.exists?(destination_file)
-              FileUtils.mkdir_p(File.dirname(destination_file))
-              File.open(destination_file, 'w') do |f|
-                f.puts "class Types::BaseInputObject < GraphQL::Schema::InputObject\nend"
-              end
-            end
-
-            destination_file = File.join(base_dir, "types", "base_enum.rb")
-            unless File.exists?(destination_file)
-              FileUtils.mkdir_p(File.dirname(destination_file))
-              File.open(destination_file, 'w') do |f|
-                f.puts "class Types::BaseEnum < GraphQL::Schema::Enum\nend"
-              end
-            end
-
-            destination_file = File.join(base_dir, "types", "base_union.rb")
-            unless File.exists?(destination_file)
-              FileUtils.mkdir_p(File.dirname(destination_file))
-              File.open(destination_file, 'w') do |f|
-                f.puts "class Types::BaseUnion < GraphQL::Schema::Union\nend"
-              end
-            end
-
-            destination_file = File.join(base_dir, "types", "base_interface.rb")
-            unless File.exists?(destination_file)
-              FileUtils.mkdir_p(File.dirname(destination_file))
-              File.open(destination_file, 'w') do |f|
-                f.puts "module Types::BaseInterface\n  include GraphQL::Schema::Interface\nend"
-              end
-            end
-
-            destination_file = File.join(base_dir, "types", "base_object.rb")
-            unless File.exists?(destination_file)
-              File.open(destination_file, 'w') do |f|
-                f.puts "class Types::BaseObject < GraphQL::Schema::Object\nend"
-              end
-            end
-          end
-
-          task :schema, [:schema_file] do |t, args|
-            schema_file = args.schema_file
-            load_upgraders
-            upgrader = GraphQL::Upgrader::Schema.new File.read(schema_file)
-
-            puts "- Transforming schema #{schema_file}"
-            File.open(schema_file, 'w') { |f| f.write upgrader.upgrade }
-          end
-
-          task :member, [:member_file] do |t, args|
-            member_file = args.member_file
-            load_upgraders
-            upgrader = GraphQL::Upgrader::Member.new File.read(member_file)
-            next unless upgrader.upgradeable?
-
-            puts "- Transforming member #{member_file}"
-            File.open(member_file, 'w') { |f| f.write upgrader.upgrade }
-          end
-        end
+    config.graphql = ActiveSupport::OrderedOptions.new
+    config.graphql.parser_cache = false
+    config.eager_load_namespaces << GraphQL
+
+    initializer("graphql.cache") do |app|
+      if config.graphql.parser_cache
+        Language::Parser.cache ||= Language::Cache.new(
+          app.root.join("tmp/cache/graphql")
+        )
       end
     end
   end

data/lib/graphql/rake_task/validate.rb

@@ -15,7 +15,7 @@ module GraphQL
       puts "Validating graphql-pro v#{version}"
       puts "  - Checking for graphql-pro credentials..."
 
-      creds = `bundle config gems.graphql.pro`[/[a-z0-9]{11}:[a-z0-9]{11}/]
+      creds = `bundle config gems.graphql.pro --parseable`[/[a-z0-9]{11}:[a-z0-9]{11}/]
       if creds.nil?
         puts "    #{ex} failed, please set with `bundle config gems.graphql.pro $MY_CREDENTIALS`"
         exit(1)