graphql-cache 0.2.5 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f508c5138bea5539cbc6e9c95bb41d5af2f5b87ef245acf972ec0a37936dbdd
-  data.tar.gz: 7af8a0cc6611334403b91f2c9ac53dba1c0fe8f60a8f9c33775e62aadbb295b4
+  metadata.gz: fb2192273e278a5586abc0e640ef6057f28e072f38b46740a5e0ebf6364f7be1
+  data.tar.gz: 59d4fd50a85cbc58a6109373f4fb4dca69aa54548960e7be62af5cb98b4cf6cd
 SHA512:
-  metadata.gz: b8d43648e3bc7dbb3f524adca874cc5724fab27f14814176f8a0100eb1eb18356670d05389a01252118be05cd329d9b5a035eae4bec0b770a132e85ec6034743
-  data.tar.gz: d0d78b24cf23ea06e2011b43c5cac05ed7f4610ef2396035d0658f42c0bb4dc471c996ce800c9e1b892e2e52d6e114d1330c6ab658391bd38fda228c32bbcec8
+  metadata.gz: 06c5fe310bf069f2017be61070b3eb809edf006473ef0f4c3e9eb27fda37278cb683a95cffceef3bd74fade59a9b76560bb7234bdfc09adc788b734667ebd110
+  data.tar.gz: dd2f2eed8a84be514eb760a98c62040f2854cc1d98c6ccb4790fe314d50b0ea75015b1ef0600e0239b080701619b0ed5496b6f305847855f2fadfa91adf4c943

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    graphql-cache (0.2.4)
+    graphql-cache (0.2.5)
       graphql (~> 1.8.0)
 
 GEM
@@ -19,6 +19,7 @@ GEM
     graphql (1.8.4)
     json (2.1.0)
     method_source (0.9.0)
+    mini_cache (1.1.0)
     pry (0.11.3)
       coderay (~> 1.1.0)
       method_source (~> 0.9.0)
@@ -36,11 +37,13 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.7.0)
     rspec-support (3.7.1)
+    sequel (5.9.0)
     simplecov (0.16.1)
       docile (~> 1.1)
       json (>= 1.8, < 3)
       simplecov-html (~> 0.10.0)
     simplecov-html (0.10.2)
+    sqlite3 (1.3.13)
     thor (0.20.0)
 
 PLATFORMS
@@ -51,10 +54,13 @@ DEPENDENCIES
   bundler (~> 1.16)
   codeclimate-test-reporter
   graphql-cache!
+  mini_cache
   pry
   rake (~> 10.0)
   rspec (~> 3.0)
+  sequel
   simplecov
+  sqlite3
 
 BUNDLED WITH
    1.16.2

data/README.md

@@ -1,79 +1,110 @@
+<img height=90 src=https://img.stackshare.io/misc/graphql-cache.png>
+
 # GraphQL Cache
-  [![Build Status](https://travis-ci.org/Leanstack/graphql-cache.svg?branch=master)](https://travis-ci.org/Leanstack/graphql-cache) [![Test Coverage](https://api.codeclimate.com/v1/badges/c8560834b10db0618175/test_coverage)](https://codeclimate.com/github/Leanstack/graphql-cache/test_coverage) [![Maintainability](https://api.codeclimate.com/v1/badges/c8560834b10db0618175/maintainability)](https://codeclimate.com/github/Leanstack/graphql-cache/maintainability)
+[![Gem Version](https://badge.fury.io/rb/graphql-cache.svg)](https://badge.fury.io/rb/graphql-cache) [![Build Status](https://travis-ci.org/stackshareio/graphql-cache.svg?branch=master)](https://travis-ci.org/stackshareio/graphql-cache) [![Test Coverage](https://api.codeclimate.com/v1/badges/524c0f23ed1dbf0f9338/test_coverage)](https://codeclimate.com/github/stackshareio/graphql-cache/test_coverage) [![Maintainability](https://api.codeclimate.com/v1/badges/524c0f23ed1dbf0f9338/maintainability)](https://codeclimate.com/github/stackshareio/graphql-cache/maintainability)
+
+A custom middleware for [graphql-ruby](https://github.com/rmosolgo/graphql-ruby)
+
+## Goals
 
-  GraphQL Cache is a custom middleware for graphql-ruby providing field-level caching.  It is currently a work in progress and the API is subject to change prior to the release v1.0.0.
+- Provide resolver-level caching for [GraphQL](https://graphql.org) APIs written in ruby
+- Configurable to work with or without Rails
+- [API Documentation](https://www.rubydoc.info/gems/graphql-cache)
+
+## Why?
+
+At [StackShare](https://stackshare.io) we've been rolling out [graphql-ruby](https://github.com/rmosolgo/graphql-ruby) for several of our new features and found ourselves in need of a caching solution.  We could have simply used `Rails.cache` in our resolvers, but this creates very verbose types or resolver classes.  It also means that each and every resolver must define it's own expiration and key.  GraphQL Cache solves that problem by integrating caching functionality into the [graphql-ruby](https://github.com/rmosolgo/graphql-ruby) resolution process making caching transparent on most fields except for a metadata flag denoting the field as cached. More details on our motivation for creating this [here](https://stackshare.io/posts/introducing-graphql-cache).
 
 ## Installation
 
-  Add this line to your application's Gemfile:
+Add this line to your application's Gemfile:
 
-  ```ruby
-  gem 'graphql-cache'
-  ```
+```ruby
+gem 'graphql-cache'
+```
 
-  And then execute:
+And then execute:
 
-      $ bundle
+```sh
+$ bundle
+```
 
-  Or install it yourself as:
+Or install it yourself as:
 
-      $ gem install graphql-cache
+```sh
+$ gem install graphql-cache
+```
 
 ## Setup
 
-  1. Add `middleware GraphQL::Cache::Middleware` to your schema
-  2. Add `field_class GraphQL::Cache::Field` to your base object type
-
-## Configuration
+1. Use GraphQL Cache as a plugin in your schema.
 
-  GraphQL Cache can be configured in an initializer:
+  ```ruby
+  class MySchema < GraphQL::Schema
+    query Types::Query
 
+    use GraphQL::Cache
+  end
+  ```
+2. Add the custom caching field class to your base object class. This adds the `cache` metadata key when defining fields.
   ```ruby
-  # config/initializers/graphql_cache.rb
-
-  GraphQL::Cache.configure do |config|
-    config.namespace = 'GraphQL::Cache' # Cache key prefix for keys generated by graphql-cache
-    config.cache     = Rails.cache      # The cache object to use for caching
-    config.logger    = Rails.logger     # Logger to receive cache-related log messages
-    config.expiry    = 5400             # 90 minutes (in seconds)
-    config.force     = false            # Cache override, when true no caching takes place
+  module Types
+    class Base < GraphQL::Schema::Object
+      field_class GraphQL::Cache::Field
+    end
   end
   ```
 
+## Configuration
+
+GraphQL Cache can be configured in an initializer:
+
+```ruby
+# config/initializers/graphql_cache.rb
+
+GraphQL::Cache.configure do |config|
+  config.namespace = 'GraphQL::Cache' # Cache key prefix for keys generated by graphql-cache
+  config.cache     = Rails.cache      # The cache object to use for caching
+  config.logger    = Rails.logger     # Logger to receive cache-related log messages
+  config.expiry    = 5400             # 90 minutes (in seconds)
+  config.force     = false            # Cache override, when true no caching takes place
+end
+```
+
 ## Usage
 
-  Any object, list, or connection field can be cached by simply adding `cache: true` to the field definition:
+Any object, list, or connection field can be cached by simply adding `cache: true` to the field definition:
 
-  ```ruby
-  field :calculated_field, Int, cache: true
-  ```
+```ruby
+field :calculated_field, Int, cache: true
+```
 
-  By default all keys will have an expiration of `GraphQL::Cache.expiry` which defaults to 90 minutes.  If you want to set a field-specific expiration time pass a hash to the `cache` parameter like this:
+By default all keys will have an expiration of `GraphQL::Cache.expiry` which defaults to 90 minutes.  If you want to set a field-specific expiration time pass a hash to the `cache` parameter like this:
 
-  ```ruby
-  field :calculated_field, Int, cache: { expiry: 10800 } # expires key after 180 minutes
-  ```
+```ruby
+field :calculated_field, Int, cache: { expiry: 10800 } # expires key after 180 minutes
+```
 
-  When passing a hash in the `cache` parameter the possible options are:
+When passing a hash in the `cache` parameter the possible options are:
 
-  - `expiry`: expiration time for this field's key in seconds (default: 5400)
-  - `force`: for cache misses on this field (default: false)
-  - `prefix`: cache key prefix (appended after GraphQL::Cache.namespace)
+- `expiry`: expiration time for this field's key in seconds (default: 5400)
+- `force`: for cache misses on this field (default: false)
+- `prefix`: cache key prefix (appended after GraphQL::Cache.namespace)
 
 ## Development
 
-  After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
-  To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 ## Contributing
 
-  Bug reports and pull requests are welcome on GitHub at https://github.com/Leanstack/graphql-cache. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+Bug reports and pull requests are welcome on GitHub at https://github.com/stackshareio/graphql-cache. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
 ## License
 
-  The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
 
 ## Code of Conduct
 
-  Everyone interacting in the Graphql::Cache project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/Leanstack/graphql-cache/blob/master/CODE_OF_CONDUCT.md).
+Everyone interacting in the graphql-cache project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/stackshareio/graphql-cache/blob/master/CODE_OF_CONDUCT.md).

data/bin/console

@@ -1,14 +1,26 @@
 #!/usr/bin/env ruby
 
-require "bundler/setup"
-require "graphql/cache"
+require 'bundler/setup'
+require 'graphql/cache'
+require 'logger'
+require 'mini_cache'
+require 'sequel'
 
-# 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.
+# Setup MiniCache for in-memory cache for dev/test
+class CacheStore < MiniCache::Store
+  alias read get
+  alias write set
+  alias clear reset
+end
 
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
+GraphQL::Cache.configure do |config|
+  config.cache = CacheStore.new
+  config.logger = Logger.new(STDOUT)
+end
 
-require "irb"
-IRB.start(__FILE__)
+# required after GraphQL::Cache initialization because dev
+# schema uses cache and logger objects from it.
+require_relative '../test_schema'
+
+require "pry"
+Pry.start

data/graphql-cache.gemspec

@@ -24,10 +24,13 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'appraisal'
   s.add_development_dependency 'bundler', '~> 1.16'
   s.add_development_dependency 'codeclimate-test-reporter'
+  s.add_development_dependency 'mini_cache'
   s.add_development_dependency 'pry'
   s.add_development_dependency 'rake',    '~> 10.0'
   s.add_development_dependency 'rspec',   '~> 3.0'
+  s.add_development_dependency 'sequel'
   s.add_development_dependency 'simplecov'
+  s.add_development_dependency 'sqlite3'
 
   s.add_dependency 'graphql', '~> 1.8.0'
 end

data/lib/graphql/cache.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
 require 'graphql/cache/version'
-require 'graphql/cache/middleware'
 require 'graphql/cache/field'
+require 'graphql/cache/key'
 require 'graphql/cache/marshal'
+require 'graphql/cache/fetcher'
 
 module GraphQL
   module Cache
@@ -43,20 +44,14 @@ module GraphQL
     # Default configuration
     @expiry    = 5400
     @force     = false
-    @namespace = 'GraphQL::Cache'
-
-    # Fetches/writes a value for `key` from the cache
-    #
-    # Always evaluates the block unless config[:metadata][:cache] is truthy
-    #
-    # @param key [String] the cache key to attempt to fetch
-    # @param config [Hash] a hash of middleware config values used to marshal cache data
-    # @option config [Hash] :metadata The metadata collected from the field definition
-    # @return [Object]
-    def self.fetch(key, config: {}, &block)
-      return block.call unless config[:metadata][:cache]
-
-      Marshal[key].read(config, &block)
+    @namespace = 'graphql'
+
+    # Called by plugin framework in graphql-ruby to
+    # bootstrap necessary instrumentation and tracing
+    # tie-ins
+    def self.use(schema_def, options: {})
+      fetcher = ::GraphQL::Cache::Fetcher.new
+      schema_def.instrument(:field, fetcher)
     end
   end
 end

data/lib/graphql/cache/deconstructor.rb

@@ -0,0 +1,78 @@
+module GraphQL
+  module Cache
+    # GraphQL objects can't be serialized to cache so we have
+    # to maintain an abstraction between the raw cache value
+    # and the GraphQL expected object. This class exposes methods
+    # for deconstructing an object to be stored in cache
+    #
+    class Deconstructor
+      # The raw value to perform actions on. Could be a raw cached value, or
+      # a raw GraphQL Field.
+      #
+      # @return [Object]
+      attr_accessor :raw
+
+      # A flag indicating the type of object construction to
+      # use when building a new GraphQL object. Can be one of
+      # 'array', 'collectionproxy', 'relation'. These values
+      # have been chosen because it is easy to use the class
+      # names of the possible object types for this purpose.
+      #
+      # @return [String] 'array' or 'collectionproxy' or 'relation'
+      attr_accessor :method
+
+      # Initializer helper that generates a valid `method` string based
+      # on `raw.class.name`.
+      #
+      # @return [Object] A newly initialized GraphQL::Cache::Deconstructor instance
+      def self.[](raw)
+        build_method = namify(raw.class.name)
+        new(raw, build_method)
+      end
+
+      # Ruby-only means of "demodularizing" a string
+      def self.namify(str)
+        str.split('::').last.downcase
+      end
+
+      def initialize(raw, method)
+        self.raw    = raw
+        self.method = method
+      end
+
+      # Deconstructs a GraphQL field into a cachable value
+      #
+      # @return [Object] A value suitable for writing to cache
+      def perform
+        if %(array collectionproxy).include? method
+          deconstruct_array(raw)
+        elsif raw.class.ancestors.include? GraphQL::Relay::BaseConnection
+          raw.nodes
+        else
+          deconstruct_object(raw)
+        end
+      end
+
+      # @private
+      def deconstruct_array(raw)
+        return [] if raw.empty?
+
+        if raw.first.class.ancestors.include? GraphQL::Schema::Object
+          raw.map(&:object)
+        else
+          raw
+        end
+      end
+
+      # @private
+      def deconstruct_object(raw)
+        if raw.respond_to?(:object)
+          raw.object
+        else
+          raw
+        end
+      end
+    end
+  end
+end
+

data/lib/graphql/cache/fetcher.rb

@@ -0,0 +1,29 @@
+module GraphQL
+  module Cache
+    class Fetcher
+      def instrument(type, field)
+        old_resolve_proc = field.resolve_proc
+
+        new_resolve_proc = lambda do |obj, args, ctx|
+          unless field.metadata[:cache]
+            return old_resolve_proc.call(obj, args, ctx)
+          end
+
+          key = cache_key(obj, args, type, field)
+
+          Marshal[key].read(field.metadata[:cache]) do
+            old_resolve_proc.call(obj, args, ctx)
+          end
+        end
+
+        # Return a copy of `field`, with the new resolve proc
+        field.redefine { resolve(new_resolve_proc) }
+      end
+
+      # @private
+      def cache_key(obj, args, type, field)
+        Key.new(obj, args, type, field).to_s
+      end
+    end
+  end
+end

data/lib/graphql/cache/key.rb

@@ -0,0 +1,88 @@
+module GraphQL
+  module Cache
+    # Represents a cache key generated from the graphql context
+    # provided when initialized
+    class Key
+      # The resolved parent object (object this resolver method is called on)
+      attr_accessor :object
+
+      # Arguments passed during graphql query execution
+      attr_accessor :arguments
+
+      # The graphql parent type
+      attr_accessor :type
+
+      # The graphql field being resolved
+      attr_accessor :field
+
+      # Metadata passed to the cache key on field definition
+      attr_accessor :metadata
+
+      # Initializes a new Key with the given graphql query context
+      def initialize(obj, args, type, field)
+        @object    = obj.object
+        @arguments = args
+        @type      = type
+        @field     = field
+        @metadata  = field.metadata[:cache]
+
+        @metadata = { cache: @metadata } unless @metadata.is_a?(Hash)
+      end
+
+      # Returns the string representation of this cache key
+      # suitable for using as a key when writing to cache
+      def to_s
+        @to_s ||= [
+          GraphQL::Cache.namespace,
+          type_clause,
+          field_clause,
+          arguments_clause,
+          object_clause
+        ].flatten.compact.join(':')
+      end
+
+      # Produces the portion of the key representing the parent object
+      def object_clause
+        return nil unless object
+
+        "#{object.class.name}:#{object_identifier}"
+      end
+
+      # Produces the portion of the key representing the parent type
+      def type_clause
+        type.name
+      end
+
+      # Produces the portion of the key representing the resolving field
+      def field_clause
+        field.name
+      end
+
+      # Produces the portion of the key representing the query arguments
+      def arguments_clause
+        @arguments_clause ||= arguments.to_h.to_a.flatten
+      end
+
+      # @private
+      def object_identifier
+        case metadata[:key]
+        when Symbol
+          object.send(metadata[:key])
+        when Proc
+          metadata[:key].call(object)
+        when NilClass
+          guess_id
+        else
+          metadata[:key]
+        end
+      end
+
+      # @private
+      def guess_id
+        return object.cache_key if object.respond_to?(:cache_key)
+        return object.id if object.respond_to?(:id)
+        object.object_id
+      end
+    end
+  end
+end

data/lib/graphql/cache/marshal.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'graphql/cache/builder'
+require 'graphql/cache/deconstructor'
 
 module GraphQL
   module Cache
@@ -27,7 +27,7 @@ module GraphQL
       # Read a value from cache if it exists and re-hydrate it or
       # execute the block and write it's result to cache
       #
-      # @param config [Hash] The middleware resolution config
+      # @param config [Hash] The object passed to `cache:` on the field definition
       # @return [Object]
       def read(config, &block)
         cached = cache.read(key)
@@ -37,17 +37,17 @@ module GraphQL
           write config, &block
         else
           logger.debug "Cache hit: (#{key})"
-          build cached, config
+          cached
         end
       end
 
       # Executes the resolution block and writes the result to cache
       #
-      # @see GraphQL::Cache::Builder#deconstruct
+      # @see GraphQL::Cache::Deconstruct#perform
       # @param config [Hash] The middleware resolution config hash
       def write(config)
         resolved = yield
-        document = Builder[resolved].deconstruct
+        document = Deconstructor[resolved].perform
 
         cache.write(key, document, expires_in: expiry(config))
         resolved
@@ -55,23 +55,13 @@ module GraphQL
 
       # @private
       def expiry(config)
-        cache_config = config[:metadata][:cache]
-
-        if cache_config.is_a?(Hash) && cache_config[:expiry]
-          config[:metadata][:cache][:expiry]
+        if config.is_a?(Hash) && config[:expiry]
+          config[:expiry]
         else
           GraphQL::Cache.expiry
         end
       end
 
-      # Uses {GraphQL::Cache::Builder} to build a valid GraphQL object
-      # from a cached value
-      #
-      # @return [Object] An object suitable to return from a GraphQL middleware
-      def build(cached, config)
-        Builder[cached].build(config)
-      end
-
       # @private
       def cache
         GraphQL::Cache.cache

data/lib/graphql/cache/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module Cache
-    VERSION = '0.2.5'
+    VERSION = '0.3.0'
   end
 end

data/test_schema.rb

@@ -0,0 +1,9 @@
+require 'logger'
+
+require_relative './test_schema/schema'
+require_relative './test_schema/models'
+require_relative './test_schema/graphql_schema'
+require_relative './test_schema/factories'
+
+Factories.bootstrap
+DB.loggers = [GraphQL::Cache.logger]

data/test_schema/factories.rb

@@ -0,0 +1,16 @@
+module Factories
+  def self.bootstrap
+    customer = Customer.create(
+      display_name: 'Michael',
+      email: 'michael@example.com'
+    )
+
+    Order.create(customer_id: customer.id, number: new_num, total_price_cents: 1399)
+    Order.create(customer_id: customer.id, number: new_num, total_price_cents: 1399)
+    Order.create(customer_id: customer.id, number: new_num, total_price_cents: 1399)
+  end
+
+  def self.new_num
+    Order.count + 1000
+  end
+end

data/test_schema/graphql_schema.rb

@@ -0,0 +1,44 @@
+require 'benchmark'
+
+class BaseType < GraphQL::Schema::Object
+  field_class GraphQL::Cache::Field
+end
+
+class OrderType < BaseType
+  field :id, Int, null: false
+  field :number, Int, null: true
+  field :total_price_cents, Int, null: true
+end
+
+class CustomerType < BaseType
+  field :display_name, String, null: false
+  field :email, String, null: false
+  field :orders, OrderType.connection_type, null: false, cache: true
+end
+
+class QueryType < BaseType
+  field :customer, CustomerType, null: true, cache: true do
+    argument :id, ID, 'Unique Identifier for querying a specific user', required: true
+  end
+
+  def customer(id:)
+    Customer[id]
+  end
+end
+
+class CacheSchema < GraphQL::Schema
+  query QueryType
+
+  use GraphQL::Cache
+
+  def self.resolve_type(_type, obj, _ctx)
+    "#{obj.class.name}Type"
+  end
+
+  def self.texecute(*args, **kwargs)
+    result = nil
+    measurement = Benchmark.measure { result = execute(*args, *kwargs) }
+    GraphQL::Cache.logger.debug("Query executed in #{measurement.real}")
+    result
+  end
+end

data/test_schema/models.rb

@@ -0,0 +1,7 @@
+class Order < Sequel::Model
+  one_to_one :customer
+end
+
+class Customer < Sequel::Model
+  one_to_many :orders
+end

data/test_schema/schema.rb

@@ -0,0 +1,16 @@
+require 'sequel'
+
+DB = Sequel.sqlite(logger: Logger.new('/dev/null'))
+
+DB.create_table :customers do
+  primary_key :id
+  String :display_name
+  String :email
+end
+
+DB.create_table :orders do
+  primary_key :id
+  Integer :customer_id
+  Integer :number
+  Integer :total_price_cents
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-cache
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.3.0
 platform: ruby
 authors:
 - Michael Kelly
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-25 00:00:00.000000000 Z
+date: 2018-07-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: appraisal
@@ -52,6 +52,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: mini_cache
+  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: pry
   requirement: !ruby/object:Gem::Requirement
@@ -94,6 +108,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: sequel
+  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: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -108,6 +136,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  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: graphql
   requirement: !ruby/object:Gem::Requirement
@@ -149,12 +191,18 @@ files:
 - gemfiles/graphql_1.8.gemfile
 - graphql-cache.gemspec
 - lib/graphql/cache.rb
-- lib/graphql/cache/builder.rb
+- lib/graphql/cache/deconstructor.rb
+- lib/graphql/cache/fetcher.rb
 - lib/graphql/cache/field.rb
+- lib/graphql/cache/key.rb
 - lib/graphql/cache/marshal.rb
-- lib/graphql/cache/middleware.rb
 - lib/graphql/cache/rails.rb
 - lib/graphql/cache/version.rb
+- test_schema.rb
+- test_schema/factories.rb
+- test_schema/graphql_schema.rb
+- test_schema/models.rb
+- test_schema/schema.rb
 homepage: https://github.com/Leanstack/graphql-cache
 licenses:
 - MIT
@@ -175,7 +223,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.3
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Caching middleware for graphql-ruby

data/lib/graphql/cache/builder.rb

@@ -1,133 +0,0 @@
-module GraphQL
-  module Cache
-    # GraphQL objects can't be serialized to cache so we have
-    # to maintain an abstraction between the raw cache value
-    # and the GraphQL expected object. This class exposes methods
-    # for both deconstructing an object to be stored in cache
-    # and re-hydrating a GraphQL object from raw cache values
-    #
-    class Builder
-      # The raw value to perform actions on. Could be a raw cached value, or
-      # a raw GraphQL Field.
-      #
-      # @return [Object]
-      attr_accessor :raw
-
-      # A flag indicating the type of object construction to
-      # use when building a new GraphQL object. Can be one of
-      # 'array', 'collectionproxy', 'relation'. These values
-      # have been chosen because it is easy to use the class
-      # names of the possible object types for this purpose.
-      #
-      # @return [String] 'array' or 'collectionproxy' or 'relation'
-      attr_accessor :method
-
-      # The middleware config hash describing a field's resolution
-      #
-      # @see GraphQL::Cache::Middleware#initialize
-      # @return [Hash]
-      attr_accessor :config
-
-      # Initializer helper that generates a valid `method` string based
-      # on `raw.class.name`.
-      #
-      # @return [Object] A newly initialized GraphQL::Cache::Builder instance
-      def self.[](raw)
-        build_method = namify(raw.class.name)
-        new(raw, build_method)
-      end
-
-      # Ruby-only means of "demodularizing" a string
-      def self.namify(str)
-        str.split('::').last.downcase
-      end
-
-      def initialize(raw, method)
-        self.raw    = raw
-        self.method = method
-      end
-
-      # Builds a compitable GraphQL object based on the resolution config
-      #
-      # @return [Object] An object suitable for returning from a GraphQL middlware call
-      def build(config)
-        self.config = config
-
-        return build_array    if method == 'array'
-        return build_relation if method == 'collectionproxy' || method == 'relation'
-        build_object
-      end
-
-      # Deconstructs a GraphQL field into a cachable value
-      #
-      # @return [Object] A value suitable for writing to cache
-      def deconstruct
-        return deconstruct_array(raw) if raw.class == Array
-        return raw.nodes if raw.class.ancestors.include? GraphQL::Relay::BaseConnection
-
-        deconstruct_object(raw)
-      end
-
-      # @private
-      def deconstruct_object(raw)
-        if raw.respond_to?(:object)
-          raw.object
-        else
-          raw
-        end
-      end
-
-      # @private
-      def deconstruct_array(raw)
-        return [] if raw.empty?
-
-        if raw.first.class.ancestors.include? GraphQL::Schema::Object
-          raw.map(&:object)
-        else
-          raw
-        end
-      end
-
-      # @private
-      def build_relation
-        GraphQL::Relay::BaseConnection.connection_for_nodes(raw).new(
-          raw,
-          config[:field_args],
-          field:   config[:query_context].field,
-          parent:  config[:parent_object].object,
-          context: config[:query_context]
-        )
-      end
-
-      # @private
-      def build_array
-        gql_def = config[:field_definition].type.unwrap.graphql_definition
-
-        raw.map do |item|
-          if gql_def.kind.name == 'OBJECT'
-            gql_def.metadata[:type_class].authorized_new(
-              item,
-              config[:query_context]
-            )
-          else
-            item
-          end
-        end
-      end
-
-      # @private
-      def build_object
-        gql_def = config[:field_definition].type.unwrap.graphql_definition
-        klass = gql_def.metadata[:type_class]
-        if gql_def.kind.name == 'OBJECT' && klass
-          klass.authorized_new(
-            raw,
-            config[:query_context]
-          )
-        else
-          raw
-        end
-      end
-    end
-  end
-end

data/lib/graphql/cache/middleware.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-module GraphQL
-  module Cache
-    # graphql-ruby middleware to wrap resolvers for caching
-    class Middleware
-      attr_accessor :parent_type, :parent_object, :object, :cache,
-                    :field_definition, :field_args, :query_context
-
-      # Called by graphql-ruby during middleware processing
-      def self.call(*args, &block)
-        new(*args).call(&block)
-      end
-
-      def initialize(parent_type,
-                     parent_object,
-                     field_definition,
-                     field_args,
-                     query_context)
-        self.parent_type      = parent_type
-        self.parent_object    = parent_object
-        self.field_definition = field_definition
-        self.field_args       = field_args
-        self.query_context    = query_context
-        self.cache            = ::GraphQL::Cache.cache
-
-        return unless parent_object
-
-        self.object = parent_object.nodes if parent_object.respond_to? :nodes
-        self.object = parent_object.object if parent_object.respond_to? :object
-      end
-
-      # @private
-      def cache_config
-        {
-          parent_type:      parent_type,
-          parent_object:    parent_object,
-          field_definition: field_definition,
-          field_args:       field_args,
-          query_context:    query_context,
-          object:           object
-        }.merge metadata_hash
-      end
-
-      # @private
-      def metadata_hash
-        {
-          metadata: {
-            cache: field_definition.metadata[:cache]
-          }
-        }
-      end
-
-      # The primary caching entry point
-      #
-      # @return [Object]
-      def call(&block)
-        GraphQL::Cache.fetch(
-          cache_key,
-          config: cache_config,
-          &block
-        )
-      end
-
-      # @private
-      def cache_key
-        @cache_key ||= [
-          GraphQL::Cache.namespace,
-          object_key,
-          field_definition.name,
-          field_args.keys
-        ].flatten
-      end
-
-      # @private
-      def object_key
-        return nil unless object
-
-        "#{object.class.name}:#{id_from_object}"
-      end
-
-      # @private
-      def id_from_object
-        return object.id if object.respond_to? :id
-        return object.fetch(:id, nil) if object.respond_to? :fetch
-        return object.fetch('id', nil) if object.respond_to? :fetch
-      end
-    end
-  end
-end