graphql-persisted_queries 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b56768c7a951fcc1f1ef63fb0bcbe054c900b0a5636579b811f5e858ed1e57b
-  data.tar.gz: 512044a14538d39037d5092860a739646771b5ad4d9deca2df522ce9ba1ef657
+  metadata.gz: 3121fbd184f715130c9f9f1956dcd89c24d52507d23ac0b35a408a9d53d54e72
+  data.tar.gz: 7e4b32a6b5d0fda8d9b135a435bca92587749ccb61664f37092c593ef4b04eb0
 SHA512:
-  metadata.gz: f6359ac33469754e332377d2c5c945cf5ce94c13609efeb603f9d2d6b5db8c08af58c290cec1ca9aa85ff048894ff1edd61a517069348ac2ea6144e7c12f8291
-  data.tar.gz: fe4f663992844109589ab001fe394e5c562f75c9eba9b95c6733f6b264a4531657a57952d7b10a30cb7692184592fa46b51cbfc89686dea358f7cbd061de3fd7
+  metadata.gz: a42f753183b5d8aa8c0d8f321a988b61375ad6ae828ef9c232e91f4f20adb5da824b6b095cb034af805e11039f5c7122d52add4cdb4caa36bb873335a85e5847
+  data.tar.gz: 539d3e7da1bed8a470555b2b411cd52a6631663e7f3927e0c9252988488800c205bfe10f4eb03b3baa34899e286420b9d743f411fefc54c9dc091a1406d75a96

data/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## master
 
+## 0.2.0 (2020-02-11)
+
+- [PR#17](https://github.com/DmitryTsepelev/graphql-ruby-persisted_queries/pull/17) Allow an optional custom error handler so that implementors can control failure scenarios when query resolution fails ([@bmorton][])
+
 ## 0.1.3 (2020-01-30)
 
 - [PR#15](https://github.com/DmitryTsepelev/graphql-ruby-persisted_queries/pull/15) Allow optional custom expiration and namespace for Redis store ([@bmorton][])

data/README.md

@@ -115,6 +115,33 @@ class GraphqlSchema < GraphQL::Schema
 end
 ```
 
+## Error handling
+
+You may optionally specify an object that will be called whenever an error occurs while attempting to resolve or save a query.  This will give you the opportunity to both handle (e.g. graceful Redis failure) and/or log the error.  By default, errors will be raised when a failure occurs within a `StoreAdapter`.
+
+An error handler can be a proc or an implementation of `GraphQL::PersistedQueries::ErrorHandlers::BaseErrorHandler`.  Here's an example for treating Redis failures as cache misses:
+
+```ruby
+class GracefulRedisErrorHandler < GraphQL::PersistedQueries::ErrorHandlers::BaseErrorHandler
+  def call(error)
+    case error
+    when Redis::BaseError
+      # Treat Redis errors as a cache miss, but you should log the error into
+      # your instrumentation framework here.
+    else
+      raise error
+    end
+
+    # Return nothing to ensure handled errors are treated as cache misses
+    return
+  end
+end
+
+class GraphqlSchema < GraphQL::Schema
+  use GraphQL::PersistedQueries, error_handler: GracefulRedisErrorHandler.new
+end
+```
+
 ## GET requests and HTTP cache
 
 Using `GET` requests for persisted queries allows you to enable HTTP caching (e.g., turn on CDN). In order to make it work you should change the way link is initialized on front-end side (`createPersistedQueryLink({ useGETForHashedQueries: true })`) and register a new route `get "/graphql", to: "graphql#execute"`.

data/lib/graphql/persisted_queries.rb

@@ -1,17 +1,21 @@
 # frozen_string_literal: true
 
+require "graphql/persisted_queries/error_handlers"
 require "graphql/persisted_queries/schema_patch"
 require "graphql/persisted_queries/store_adapters"
 require "graphql/persisted_queries/version"
+require "graphql/persisted_queries/builder_helpers"
 
 module GraphQL
   # Plugin definition
   module PersistedQueries
-    def self.use(schema_defn, store: :memory, hash_generator: :sha256, **options)
+    def self.use(schema_defn, store: :memory, hash_generator: :sha256,
+                 error_handler: :default, **options)
       schema = schema_defn.is_a?(Class) ? schema_defn : schema_defn.target
 
       schema.singleton_class.prepend(SchemaPatch)
       schema.hash_generator = hash_generator
+      schema.configure_persisted_query_error_handler(error_handler)
       schema.configure_persisted_query_store(store, options)
     end
   end

data/lib/graphql/persisted_queries/builder_helpers.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module PersistedQueries
+    # Contains factory methods for error handlers
+    module BuilderHelpers
+      def self.camelize(name)
+        name.to_s.split("_").map(&:capitalize).join
+      end
+    end
+  end
+end

data/lib/graphql/persisted_queries/error_handlers.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "graphql/persisted_queries/error_handlers/base_error_handler"
+require "graphql/persisted_queries/error_handlers/default_error_handler"
+
+module GraphQL
+  module PersistedQueries
+    # Contains factory methods for error handlers
+    module ErrorHandlers
+      def self.build(handler, options = nil)
+        if handler.is_a?(ErrorHandlers::BaseErrorHandler)
+          handler
+        elsif handler.is_a?(Proc)
+          build_from_proc(handler)
+        else
+          build_by_name(handler, options)
+        end
+      end
+
+      def self.build_from_proc(proc)
+        if proc.arity != 1
+          raise ArgumentError, "proc passed to :error_handler should have exactly one argument"
+        end
+
+        proc
+      end
+
+      def self.build_by_name(name, options)
+        const_get("#{BuilderHelpers.camelize(name)}ErrorHandler").new(options || {})
+      rescue NameError => e
+        raise e.class, "Persisted query error handler for :#{name} haven't been found", e.backtrace
+      end
+    end
+  end
+end

data/lib/graphql/persisted_queries/error_handlers/base_error_handler.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module PersistedQueries
+    module ErrorHandlers
+      # Base class for all error handlers
+      class BaseErrorHandler
+        def initialize(_options); end
+
+        def call(_error)
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/graphql/persisted_queries/error_handlers/default_error_handler.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module PersistedQueries
+    module ErrorHandlers
+      # Default error handler for simply re-raising the error
+      class DefaultErrorHandler < BaseErrorHandler
+        def call(error)
+          raise error
+        end
+      end
+    end
+  end
+end

data/lib/graphql/persisted_queries/resolver.rb

@@ -18,10 +18,11 @@ module GraphQL
         end
       end
 
-      def initialize(extensions, store, hash_generator_proc)
+      def initialize(extensions, store, hash_generator_proc, error_handler)
         @extensions = extensions
         @store = store
         @hash_generator_proc = hash_generator_proc
+        @error_handler = error_handler
       end
 
       def resolve(query_str)
@@ -30,7 +31,7 @@ module GraphQL
         if query_str
           persist_query(query_str)
         else
-          query_str = @store.fetch_query(hash)
+          query_str = with_error_handling { @store.fetch_query(hash) }
           raise NotFound if query_str.nil?
         end
 
@@ -39,10 +40,16 @@ module GraphQL
 
       private
 
+      def with_error_handling
+        yield
+      rescue StandardError => e
+        @error_handler.call(e)
+      end
+
       def persist_query(query_str)
         raise WrongHash if @hash_generator_proc.call(query_str) != hash
 
-        @store.save_query(hash, query_str)
+        with_error_handling { @store.save_query(hash, query_str) }
       end
 
       def hash

data/lib/graphql/persisted_queries/schema_patch.rb

@@ -7,19 +7,24 @@ module GraphQL
   module PersistedQueries
     # Patches GraphQL::Schema to support persisted queries
     module SchemaPatch
-      attr_reader :persisted_query_store, :hash_generator_proc
+      attr_reader :persisted_query_store, :hash_generator_proc, :persisted_query_error_handler
 
       def configure_persisted_query_store(store, options)
         @persisted_query_store = StoreAdapters.build(store, options)
       end
 
+      def configure_persisted_query_error_handler(handler)
+        @persisted_query_error_handler = ErrorHandlers.build(handler)
+      end
+
       def hash_generator=(hash_generator)
         @hash_generator_proc = HashGeneratorBuilder.new(hash_generator).build
       end
 
       def execute(query_str = nil, **kwargs)
         if (extensions = kwargs.delete(:extensions))
-          resolver = Resolver.new(extensions, persisted_query_store, hash_generator_proc)
+          resolver = Resolver.new(extensions, persisted_query_store, hash_generator_proc,
+                                  persisted_query_error_handler)
           query_str = resolver.resolve(query_str)
         end
 

data/lib/graphql/persisted_queries/store_adapters.rb

@@ -17,9 +17,7 @@ module GraphQL
       end
 
       def self.build_by_name(name, options)
-        camelized_adapter = name.to_s.split("_").map(&:capitalize).join
-        adapter_class_name = "#{camelized_adapter}StoreAdapter"
-        StoreAdapters.const_get(adapter_class_name).new(options || {})
+        const_get("#{BuilderHelpers.camelize(name)}StoreAdapter").new(options || {})
       rescue NameError => e
         raise e.class, "Persisted query store adapter for :#{name} haven't been found", e.backtrace
       end

data/lib/graphql/persisted_queries/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module PersistedQueries
-    VERSION = "0.1.3"
+    VERSION = "0.2.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-persisted_queries
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - DmitryTsepelev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-01-31 00:00:00.000000000 Z
+date: 2020-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -117,6 +117,10 @@ files:
 - gemfiles/graphql_master.gemfile
 - graphql-persisted_queries.gemspec
 - lib/graphql/persisted_queries.rb
+- lib/graphql/persisted_queries/builder_helpers.rb
+- lib/graphql/persisted_queries/error_handlers.rb
+- lib/graphql/persisted_queries/error_handlers/base_error_handler.rb
+- lib/graphql/persisted_queries/error_handlers/default_error_handler.rb
 - lib/graphql/persisted_queries/hash_generator_builder.rb
 - lib/graphql/persisted_queries/resolver.rb
 - lib/graphql/persisted_queries/schema_patch.rb