graphql-fragment_cache 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 385b7910c87bd9fe82d32d4d1e6ac45c9d62600b2cbcc1422445c47fca70d021
+  data.tar.gz: a99f8ef1ffaa3026ee2f183b74abc1dea8fab099f0a2c811de1f211adf4e176d
+SHA512:
+  metadata.gz: 3e1936a4c8d932cf022ffaa45c79d67b3217729f7b722f3209995706a9b1c6c4346c272078c1c9404707a1833b0ef786399bde0b76431eedead4ed0cb7cfcfa0
+  data.tar.gz: 2a550ee8ba377ec9d199266fb75bdd9fe51bb46595c8839d5d0a9a43f9c3874b897d73b718fb66b4f2891721dbac56a436d05f66ad197f5ca31a973f6c592b41

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Change log
+
+## master
+
+## 0.1.0 (2020-04-14)
+
+- Initial version ([@DmitryTsepelev][], [@palkan][], [@ssnickolay][])
+
+[@DmitryTsepelev]: https://github.com/DmitryTsepelev
+[@palkan]: https://github.com/palkan
+[@ssnickolay]: https://github.com/ssnickolay

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 DmitryTsepelev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,283 @@
+# GraphQL::FragmentCache ![CI](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/workflows/CI/badge.svg?branch=master)
+
+`GraphQL::FragmentCache` powers up [graphql-ruby](https://graphql-ruby.org) with the ability to cache response _fragments_: you can mark any field as cached and it will never be resolved again (at least, while cache is valid). For instance, the following code caches `title` for each post:
+
+```ruby
+class PostType < BaseObject
+  field :id, ID, null: false
+  field :title, String, null: false, cache_fragment: true
+end
+```
+
+<p align="center">
+  <a href="https://evilmartians.com/?utm_source=graphql-ruby-fragment_cache">
+    <img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg" alt="Sponsored by Evil Martians" width="236" height="54">
+  </a>
+</p>
+
+## Getting started
+
+Add the gem to your Gemfile `gem 'graphql-fragment_cache'` and add the plugin to your schema class (make sure to turn interpreter mode on with AST analysis!):
+
+```ruby
+class GraphqSchema < GraphQL::Schema
+  use GraphQL::Execution::Interpreter
+  use GraphQL::Analysis::AST
+
+  use GraphQL::FragmentCache
+
+  query QueryType
+end
+```
+
+Include `GraphQL::FragmentCache::Object` to your base type class:
+
+```ruby
+class BaseType < GraphQL::Schema::Object
+  include GraphQL::FragmentCache::Object
+end
+```
+
+Now you can add `cache_fragment:` option to your fields to turn caching on:
+
+```ruby
+class PostType < BaseObject
+  field :id, ID, null: false
+  field :title, String, null: false, cache_fragment: true
+end
+```
+
+Alternatively, you can use `cache_fragment` method inside resolvers:
+
+```ruby
+class QueryType < BaseObject
+  field :post, PostType, null: true do
+    argument :id, ID, required: true
+  end
+
+  def post(id:)
+    cache_fragment { Post.find(id) }
+  end
+end
+```
+
+## Cache key generation
+
+Cache keys consist of implicit and explicit (provided by user) parts.
+
+### Implicit cache key
+
+Implicit part of a cache key (its prefix) contains the information about the schema and the current query. It includes:
+
+- Hex gsdigest of the schema definition (to make sure cache is cleared when the schema changes).
+- The current query fingerprint consisting of a _path_ to the field, arguments information and the selections set.
+
+Let's take a look at the example:
+
+```ruby
+query = <<~GQL
+  query {
+    post(id: 1) {
+      id
+      title
+      cachedAuthor {
+        id
+        name
+      }
+    }
+  }
+GQL
+
+schema_cache_key = GraphqSchema.schema_cache_key
+
+path_cache_key = "post(id:1)/cachedAuthor"
+selections_cache_key = "[#{%w[id name].join(".")}]"
+
+query_cache_key = Digest::SHA1.hexdigest("#{path_cache_key}#{selections_cache_key}")
+
+cache_key = "#{schema_cache_key}/#{query_cache_key}"
+```
+
+You can override `schema_cache_key` or `query_cache_key` by passing parameters to the `cache_fragment` calls:
+
+```ruby
+class QueryType < BaseObject
+  field :post, PostType, null: true do
+    argument :id, ID, required: true
+  end
+
+  def post(id:)
+    cache_fragment(query_cache_key: "post(#{id})") { Post.find(id) }
+  end
+end
+```
+
+Same for the option:
+
+```ruby
+class PostType < BaseObject
+  field :id, ID, null: false
+  field :title, String, null: false, cache_fragment: {query_cache_key: "post_title"}
+end
+```
+
+### User-provided cache key
+
+In most cases you want your cache key to depend on the resolved object (say, `ActiveRecord` model). You can do that by passing an argument to the `#cache_fragment` method in a similar way to Rails views [`#cache` method](https://guides.rubyonrails.org/caching_with_rails.html#fragment-caching):
+
+```ruby
+def post(id:)
+  post = Post.find(id)
+  cache_fragment(post) { post }
+end
+```
+
+You can pass arrays as well to build a compound cache key:
+
+```ruby
+def post(id:)
+  post = Post.find(id)
+  cache_fragment([post, current_account]) { post }
+end
+```
+
+You can omit the block if its return value is the same as the cached object:
+
+```ruby
+# the following line
+cache_fragment(post)
+# is the same as
+cache_fragment(post) { post }
+```
+
+When using `cache_fragment:` option, it's only possible to use the resolved value as a cache key by setting:
+
+```ruby
+field :post, PostType, null: true, cache_fragment: {cache_key: :object} do
+  argument :id, ID, required: true
+end
+
+# this is equal to
+def post(id:)
+  cache_fragment(Post.find(id))
+end
+```
+
+Also, you can pass `:value` to the `cache_key:` argument to use the returned value to build a key:
+
+```ruby
+field :post, PostType, null: true, cache_fragment: {cache_key: :value} do
+  argument :id, ID, required: true
+end
+
+# this is equal to
+def post(id:)
+  post = Post.find(id)
+  cache_fragment(post) { post }
+end
+```
+
+The way cache key part is generated for the passed argument is the following:
+
+- Use `#graphql_cache_key` if implemented.
+- Use `#cache_key` (or `#cache_key_with_version` for modern Rails) if implemented.
+- Use `self.to_s` for _primitive_ types (strings, symbols, numbers, booleans).
+- Raise `ArgumentError` if none of the above.
+
+### Context cache key
+
+By default, we do not take context into account when calculating cache keys. That's because caching is more efficient when it's _context-free_.
+
+However, if you want some fields to be cached per context, you can do that either by passing context objects directly to the `#cache_fragment` method (see above) or by adding a `context_key` option to `cache_fragment:`.
+
+For instance, imagine a query that allows the current user's social profiles:
+
+```gql
+query {
+  socialProfiles {
+    provider
+    id
+  }
+}
+```
+
+You can cache the result using the context (`context[:user]`) as a cache key:
+
+```ruby
+class QueryType < BaseObject
+  field :social_profiles, [SocialProfileType], null: false, cache_fragment: {context_key: :user}
+
+  def social_profiles
+    context[:user].social_profiles
+  end
+end
+```
+
+This is equal to using `#cache_fragment` the following way:
+
+```ruby
+class QueryType < BaseObject
+  field :social_profiles, [SocialProfileType], null: false
+
+  def social_profiles
+    cache_fragment(context[:user]) { context[:user].social_profiles }
+  end
+end
+```
+
+## Cache storage and options
+
+It's up to your to decide which caching engine to use, all you need is to configure the cache store:
+
+```ruby
+GraphQL::FragmentCache.cache_store = MyCacheStore.new
+```
+
+Or, in Rails:
+
+```ruby
+# config/application.rb (or config/environments/<environment>.rb)
+Rails.application.configure do |config|
+  # arguments and options are the same as for `config.cache_store`
+  config.graphql_fragment_cache.store = :redis_cache_store
+end
+```
+
+⚠️ Cache store must implement `#read(key)` and `#write(key, value, **options)` methods.
+
+The gem provides only in-memory store out-of-the-box (`GraphQL::FragmentCache::MemoryStore`). It's used by default.
+
+You can pass store-specific options to `#cache_fragment` or `cache_fragment:`. For example, to set expiration (assuming the store's `#write` method supports `expires_in` option):
+
+```ruby
+class PostType < BaseObject
+  field :id, ID, null: false
+  field :title, String, null: false, cache_fragment: {expires_in: 5.minutes}
+end
+
+class QueryType < BaseObject
+  field :post, PostType, null: true do
+    argument :id, ID, required: true
+  end
+
+  def post(id:)
+    cache_fragment(expires_in: 5.minutes) { Post.find(id) }
+  end
+end
+```
+
+## Limitations
+
+- [Field aliases](https://spec.graphql.org/June2018/#sec-Field-Alias) are not currently supported (take a look at the failing spec [here](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/7))
+
+## Credits
+
+Based on the original [gist](https://gist.github.com/palkan/faad9f6ff1db16fcdb1c071ec50e4190) by [@palkan](https://github.com/palkan) and [@ssnickolay](https://github.com/ssnickolay).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at [https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "graphql/ruby/fragment_cache"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/.rbnext/2.7/graphql/fragment_cache/cache_key_builder.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "json"
+require "digest"
+
+using RubyNext
+
+module GraphQL
+  module FragmentCache
+    using Ext
+
+    using(Module.new {
+      refine Array do
+        def to_selections_key
+          map { |val|
+            children = val.selections.empty? ? "" : "[#{val.selections.to_selections_key}]"
+            "#{val.field.name}#{children}"
+          }.join(".")
+        end
+      end
+    })
+
+    # Builds cache key for fragment
+    class CacheKeyBuilder
+      using RubyNext
+
+      class << self
+        def call(**options)
+          new(**options).build
+        end
+      end
+
+      attr_reader :query, :path, :object, :schema
+
+      def initialize(object: nil, query:, path:, **options)
+        @object = object
+        @query = query
+        @schema = query.schema
+        @path = path
+        @options = options
+      end
+
+      def build
+        Digest::SHA1.hexdigest("#{schema_cache_key}/#{query_cache_key}").then do |base_key|
+          next base_key unless object
+          "#{base_key}/#{object_key(object)}"
+        end
+      end
+
+      private
+
+      def schema_cache_key
+        @options.fetch(:schema_cache_key, schema.schema_cache_key)
+      end
+
+      def query_cache_key
+        @options.fetch(:query_cache_key, "#{path_cache_key}[#{selections_cache_key}]")
+      end
+
+      def selections_cache_key
+        current_root =
+          path.reduce(query.lookahead) { |lkhd, name| lkhd.selection(name) }
+
+        current_root.selections.to_selections_key
+      end
+
+      def path_cache_key
+        lookahead = query.lookahead
+
+        path.map { |field_name|
+          lookahead = lookahead.selection(field_name)
+
+          next field_name if lookahead.arguments.empty?
+
+          args = lookahead.arguments.map { |_1, _2| "#{_1}:#{_2}" }.sort.join(",")
+          "#{field_name}(#{args})"
+        }.join("/")
+      end
+
+      def object_key(obj)
+        obj._graphql_cache_key
+      end
+    end
+  end
+end

data/lib/.rbnext/2.7/graphql/fragment_cache/cacher.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module FragmentCache
+    using Ext
+
+    # Saves resolved fragment values to cache store
+    module Cacher
+      class << self
+        def call(query)
+          return unless query.context.fragments?
+
+          final_value = query.context.namespace(:interpreter)[:runtime].final_value
+
+          query.context.fragments.each { |_1| _1.persist(final_value) }
+        end
+      end
+    end
+  end
+end

data/lib/.rbnext/2.7/graphql/fragment_cache/ext/graphql_cache_key.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module FragmentCache
+    module Ext
+      # Adds #_graphql_cache_key method to Object,
+      # which just call #graphql_cache_key or #cache_key.
+      #
+      # For other core classes returns string representation.
+      #
+      # Raises ArgumentError otherwise.
+      #
+      # We use a refinement to avoid case/if statements for type checking
+      refine Object do
+        def _graphql_cache_key
+          return graphql_cache_key if respond_to?(:graphql_cache_key)
+          return cache_key if respond_to?(:cache_key)
+          return to_a._graphql_cache_key if respond_to?(:to_a)
+
+          to_s
+        end
+      end
+
+      refine Array do
+        def _graphql_cache_key
+          map { |_1| _1._graphql_cache_key }.join("/")
+        end
+      end
+
+      refine NilClass do
+        def _graphql_cache_key
+          ""
+        end
+      end
+
+      refine TrueClass do
+        def _graphql_cache_key
+          "t"
+        end
+      end
+
+      refine FalseClass do
+        def _graphql_cache_key
+          "f"
+        end
+      end
+
+      refine String do
+        def _graphql_cache_key
+          self
+        end
+      end
+
+      refine Symbol do
+        def _graphql_cache_key
+          to_s
+        end
+      end
+
+      if RUBY_PLATFORM.match?(/java/i)
+        refine Integer do
+          def _graphql_cache_key
+            to_s
+          end
+        end
+
+        refine Float do
+          def _graphql_cache_key
+            to_s
+          end
+        end
+      else
+        refine Numeric do
+          def _graphql_cache_key
+            to_s
+          end
+        end
+      end
+
+      refine Time do
+        def _graphql_cache_key
+          to_s
+        end
+      end
+
+      refine Module do
+        def _graphql_cache_key
+          name
+        end
+      end
+    end
+  end
+end

data/lib/graphql-fragment_cache.rb

@@ -0,0 +1,6 @@
+require "ruby-next"
+
+require "ruby-next/language/setup"
+RubyNext::Language.setup_gem_load_path
+
+require "graphql/fragment_cache"

data/lib/graphql/fragment_cache.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "graphql"
+
+require "graphql/fragment_cache/ext/context_fragments"
+require "graphql/fragment_cache/ext/graphql_cache_key"
+
+require "graphql/fragment_cache/schema_patch"
+require "graphql/fragment_cache/object"
+require "graphql/fragment_cache/instrumentation"
+
+require "graphql/fragment_cache/memory_store"
+
+require "graphql/fragment_cache/version"
+require "graphql/fragment_cache/railtie" if defined?(Rails::Railtie)
+
+module GraphQL
+  # Plugin definition
+  module FragmentCache
+    class << self
+      attr_reader :cache_store
+
+      def use(schema_defn, options = {})
+        verify_interpreter!(schema_defn)
+
+        schema_defn.instrument(:query, Instrumentation)
+        schema_defn.extend(SchemaPatch)
+      end
+
+      def cache_store=(store)
+        unless store.respond_to?(:read)
+          raise ArgumentError, "Store must implement #read(key) method"
+        end
+
+        unless store.respond_to?(:write)
+          raise ArgumentError, "Store must implement #write(key, val, **options) method"
+        end
+
+        @cache_store = store
+      end
+
+      private
+
+      def verify_interpreter!(schema_defn)
+        unless schema_defn.interpreter?
+          raise StandardError,
+            "GraphQL::Execution::Interpreter should be enabled for fragment caching"
+        end
+
+        unless schema_defn.analysis_engine == GraphQL::Analysis::AST
+          raise StandardError,
+            "GraphQL::Analysis::AST should be enabled for fragment caching"
+        end
+      end
+    end
+
+    self.cache_store = MemoryStore.new
+  end
+end

data/lib/graphql/fragment_cache/cache_key_builder.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "json"
+require "digest"
+
+using RubyNext
+
+module GraphQL
+  module FragmentCache
+    using Ext
+
+    using(Module.new {
+      refine Array do
+        def to_selections_key
+          map { |val|
+            children = val.selections.empty? ? "" : "[#{val.selections.to_selections_key}]"
+            "#{val.field.name}#{children}"
+          }.join(".")
+        end
+      end
+    })
+
+    # Builds cache key for fragment
+    class CacheKeyBuilder
+      using RubyNext
+
+      class << self
+        def call(**options)
+          new(**options).build
+        end
+      end
+
+      attr_reader :query, :path, :object, :schema
+
+      def initialize(object: nil, query:, path:, **options)
+        @object = object
+        @query = query
+        @schema = query.schema
+        @path = path
+        @options = options
+      end
+
+      def build
+        Digest::SHA1.hexdigest("#{schema_cache_key}/#{query_cache_key}").then do |base_key|
+          next base_key unless object
+          "#{base_key}/#{object_key(object)}"
+        end
+      end
+
+      private
+
+      def schema_cache_key
+        @options.fetch(:schema_cache_key, schema.schema_cache_key)
+      end
+
+      def query_cache_key
+        @options.fetch(:query_cache_key, "#{path_cache_key}[#{selections_cache_key}]")
+      end
+
+      def selections_cache_key
+        current_root =
+          path.reduce(query.lookahead) { |lkhd, name| lkhd.selection(name) }
+
+        current_root.selections.to_selections_key
+      end
+
+      def path_cache_key
+        lookahead = query.lookahead
+
+        path.map { |field_name|
+          lookahead = lookahead.selection(field_name)
+
+          next field_name if lookahead.arguments.empty?
+
+          args = lookahead.arguments.map { "#{_1}:#{_2}" }.sort.join(",")
+          "#{field_name}(#{args})"
+        }.join("/")
+      end
+
+      def object_key(obj)
+        obj._graphql_cache_key
+      end
+    end
+  end
+end

data/lib/graphql/fragment_cache/cacher.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module FragmentCache
+    using Ext
+
+    # Saves resolved fragment values to cache store
+    module Cacher
+      class << self
+        def call(query)
+          return unless query.context.fragments?
+
+          final_value = query.context.namespace(:interpreter)[:runtime].final_value
+
+          query.context.fragments.each { _1.persist(final_value) }
+        end
+      end
+    end
+  end
+end

data/lib/graphql/fragment_cache/ext/context_fragments.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module FragmentCache
+    module Ext
+      # Add ability to access fragments via `context.fragments`
+      # without dupclicating the storage logic and monkey-patching
+      refine GraphQL::Query::Context do
+        def fragments?
+          namespace(:fragment_cache)[:fragments]
+        end
+
+        def fragments
+          namespace(:fragment_cache)[:fragments] ||= []
+        end
+      end
+    end
+  end
+end

data/lib/graphql/fragment_cache/ext/graphql_cache_key.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module FragmentCache
+    module Ext
+      # Adds #_graphql_cache_key method to Object,
+      # which just call #graphql_cache_key or #cache_key.
+      #
+      # For other core classes returns string representation.
+      #
+      # Raises ArgumentError otherwise.
+      #
+      # We use a refinement to avoid case/if statements for type checking
+      refine Object do
+        def _graphql_cache_key
+          return graphql_cache_key if respond_to?(:graphql_cache_key)
+          return cache_key if respond_to?(:cache_key)
+          return to_a._graphql_cache_key if respond_to?(:to_a)
+
+          to_s
+        end
+      end
+
+      refine Array do
+        def _graphql_cache_key
+          map { _1._graphql_cache_key }.join("/")
+        end
+      end
+
+      refine NilClass do
+        def _graphql_cache_key
+          ""
+        end
+      end
+
+      refine TrueClass do
+        def _graphql_cache_key
+          "t"
+        end
+      end
+
+      refine FalseClass do
+        def _graphql_cache_key
+          "f"
+        end
+      end
+
+      refine String do
+        def _graphql_cache_key
+          self
+        end
+      end
+
+      refine Symbol do
+        def _graphql_cache_key
+          to_s
+        end
+      end
+
+      if RUBY_PLATFORM.match?(/java/i)
+        refine Integer do
+          def _graphql_cache_key
+            to_s
+          end
+        end
+
+        refine Float do
+          def _graphql_cache_key
+            to_s
+          end
+        end
+      else
+        refine Numeric do
+          def _graphql_cache_key
+            to_s
+          end
+        end
+      end
+
+      refine Time do
+        def _graphql_cache_key
+          to_s
+        end
+      end
+
+      refine Module do
+        def _graphql_cache_key
+          name
+        end
+      end
+    end
+  end
+end

data/lib/graphql/fragment_cache/field_extension.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module FragmentCache
+    # Wraps resolver with cache method
+    class FieldExtension < GraphQL::Schema::FieldExtension
+      module Patch
+        def initialize(*args, **kwargs, &block)
+          cache_fragment = kwargs.delete(:cache_fragment)
+
+          if cache_fragment
+            kwargs[:extensions] ||= []
+            kwargs[:extensions] << build_extension(cache_fragment)
+          end
+
+          super
+        end
+
+        private
+
+        def build_extension(options)
+          if options.is_a?(Hash)
+            {FieldExtension => options}
+          else
+            FieldExtension
+          end
+        end
+      end
+
+      def initialize(options:, **_rest)
+        @cache_options = options || {}
+
+        @context_key = @cache_options.delete(:context_key)
+        @cache_key = @cache_options.delete(:cache_key)
+      end
+
+      def resolve(object:, arguments:, **_options)
+        resolved_value = yield(object, arguments)
+
+        object_for_key = if @context_key
+          Array(@context_key).map { |key| object.context[key] }
+        elsif @cache_key == :object
+          object.object
+        elsif @cache_key == :value
+          resolved_value
+        end
+
+        cache_fragment_options = @cache_options.merge(object: object_for_key)
+
+        object.cache_fragment(cache_fragment_options) { resolved_value }
+      end
+    end
+  end
+end

data/lib/graphql/fragment_cache/fragment.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "graphql/fragment_cache/cache_key_builder"
+
+module GraphQL
+  module FragmentCache
+    # Represents a single fragment to cache
+    class Fragment
+      attr_reader :options, :path, :context
+
+      def initialize(context, **options)
+        @context = context
+        @options = options
+        @path = context.namespace(:interpreter)[:current_path]
+      end
+
+      def read
+        FragmentCache.cache_store.read(cache_key)
+      end
+
+      def persist(final_value)
+        value = resolve(final_value)
+        FragmentCache.cache_store.write(cache_key, value, **options)
+      end
+
+      private
+
+      def cache_key
+        @cache_key ||= CacheKeyBuilder.call(path: path, query: context.query, **options)
+      end
+
+      def resolve(final_value)
+        final_value.dig(*path)
+      end
+    end
+  end
+end

data/lib/graphql/fragment_cache/instrumentation.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "graphql/fragment_cache/cacher"
+
+module GraphQL
+  module FragmentCache
+    # Adds hook for saving cached values after query is resolved
+    module Instrumentation
+      module_function
+
+      def before_query(query)
+      end
+
+      def after_query(query)
+        return unless query.valid?
+
+        Cacher.call(query)
+      end
+    end
+  end
+end

data/lib/graphql/fragment_cache/memory_store.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+using RubyNext
+
+module GraphQL
+  module FragmentCache
+    # Memory adapter for storing cached fragments
+    class MemoryStore
+      using RubyNext
+
+      class Entry < Struct.new(:value, :expires_at, keyword_init: true)
+        def expired?
+          expires_at && expires_at < Time.now
+        end
+      end
+
+      attr_reader :default_expires_in
+
+      def initialize(expires_in: nil, **other)
+        raise ArgumentError, "Unsupported options: #{other.keys.join(",")}" unless other.empty?
+
+        @default_expires_in = expires_in
+        @storage = {}
+      end
+
+      def read(key)
+        key = key.to_s
+        storage[key]&.then do |entry|
+          if entry.expired?
+            delete(key)
+            next
+          end
+          entry.value
+        end
+      end
+
+      def write(key, value, expires_in: default_expires_in, **options)
+        key = key.to_s
+        @storage[key] = Entry.new(value: value, expires_at: expires_in ? Time.now + expires_in : nil)
+      end
+
+      def delete(key)
+        key = key.to_s
+        storage.delete(key)
+      end
+
+      def clear
+        storage.clear
+      end
+
+      private
+
+      attr_reader :storage
+    end
+  end
+end

data/lib/graphql/fragment_cache/object.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "graphql/fragment_cache/object_helpers"
+require "graphql/fragment_cache/field_extension"
+
+module GraphQL
+  module FragmentCache
+    # Adds #cache_fragment method and kwarg option
+    module Object
+      def self.included(base)
+        base.include(GraphQL::FragmentCache::ObjectHelpers)
+        base.field_class.prepend(GraphQL::FragmentCache::FieldExtension::Patch)
+      end
+    end
+  end
+end

data/lib/graphql/fragment_cache/object_helpers.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "graphql/fragment_cache/fragment"
+
+module GraphQL
+  module FragmentCache
+    using Ext
+
+    # Adds #cache_fragment method
+    module ObjectHelpers
+      def cache_fragment(object_to_cache = nil, **options, &block)
+        fragment = Fragment.new(context, options)
+
+        if (cached = fragment.read)
+          return raw_value(cached)
+        end
+
+        context.fragments << fragment
+
+        object_to_cache || block.call
+      end
+    end
+  end
+end

data/lib/graphql/fragment_cache/rails/cache_key_builder.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module FragmentCache
+    # Extends key builder to use .expand_cache_key in Rails
+    class CacheKeyBuilder
+      def object_key(obj)
+        return obj.graphql_cache_key if obj.respond_to?(:graphql_cache_key)
+        return obj.map { |item| object_key(item) }.join("/") if obj.is_a?(Array)
+        return object_key(obj.to_a) if obj.respond_to?(:to_a)
+
+        ActiveSupport::Cache.expand_cache_key(obj)
+      end
+    end
+  end
+end

data/lib/graphql/fragment_cache/railtie.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "graphql/fragment_cache/rails/cache_key_builder"
+
+module GraphQL
+  module FragmentCache
+    class Railtie < ::Rails::Railtie # :nodoc:
+      # Provides Rails-specific configuration,
+      # accessible through `Rails.application.config.graphql_fragment_cache`
+      module Config
+        class << self
+          def store=(store)
+            # Handle both:
+            #   store = :memory
+            #   store = :mem_cache, ENV['MEMCACHE']
+            if store.is_a?(Symbol) || store.is_a?(Array)
+              store = ActiveSupport::Cache.lookup_store(store)
+            end
+
+            FragmentCache.cache_store = store
+          end
+        end
+      end
+
+      config.graphql_fragment_cache = Config
+    end
+  end
+end

data/lib/graphql/fragment_cache/schema_patch.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "digest/sha1"
+
+module GraphQL
+  module FragmentCache
+    # Patches GraphQL::Schema to support fragment cache
+    module SchemaPatch
+      def schema_cache_key
+        @schema_cache_key ||= Digest::SHA1.hexdigest(to_definition)
+      end
+    end
+  end
+end

data/lib/graphql/fragment_cache/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module FragmentCache
+    VERSION = "0.1.0"
+  end
+end

metadata

@@ -0,0 +1,168 @@
+--- !ruby/object:Gem::Specification
+name: graphql-fragment_cache
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- DmitryTsepelev
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-04-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: graphql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.10.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.10.3
+- !ruby/object:Gem::Dependency
+  name: ruby-next-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.1
+- !ruby/object:Gem::Dependency
+  name: combustion
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ruby-next
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.5'
+description: Fragment cache for graphql-ruby
+email:
+- dmitry.a.tsepelev@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- bin/console
+- bin/setup
+- lib/.rbnext/2.7/graphql/fragment_cache/cache_key_builder.rb
+- lib/.rbnext/2.7/graphql/fragment_cache/cacher.rb
+- lib/.rbnext/2.7/graphql/fragment_cache/ext/graphql_cache_key.rb
+- lib/graphql-fragment_cache.rb
+- lib/graphql/fragment_cache.rb
+- lib/graphql/fragment_cache/cache_key_builder.rb
+- lib/graphql/fragment_cache/cacher.rb
+- lib/graphql/fragment_cache/ext/context_fragments.rb
+- lib/graphql/fragment_cache/ext/graphql_cache_key.rb
+- lib/graphql/fragment_cache/field_extension.rb
+- lib/graphql/fragment_cache/fragment.rb
+- lib/graphql/fragment_cache/instrumentation.rb
+- lib/graphql/fragment_cache/memory_store.rb
+- lib/graphql/fragment_cache/object.rb
+- lib/graphql/fragment_cache/object_helpers.rb
+- lib/graphql/fragment_cache/rails/cache_key_builder.rb
+- lib/graphql/fragment_cache/railtie.rb
+- lib/graphql/fragment_cache/schema_patch.rb
+- lib/graphql/fragment_cache/version.rb
+homepage: https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache
+  source_code_uri: https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache
+  changelog_uri: https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Fragment cache for graphql-ruby
+test_files: []