graphql-result_cache 0.1.8 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c6f11b53f28b2c9c5bd70a0f985b106e6a8b530d1a236122db13cacd3f92229c
-  data.tar.gz: 37dea5a5328235136a09cb983f800b4cd91fa227fc20f2501d3a766ec7c00508
+  metadata.gz: 535b29453885101a889e6228ded5fd20a83dd6e09f104fc3e9f369e1324b2d28
+  data.tar.gz: e8bad278755e2357bd12aa64ecf3e6078f307ede91625e21ed6794f5e6731144
 SHA512:
-  metadata.gz: 64120b5bfb3d1e5ca80d3fb01d01a158cd441eaeda3640da504080edb04070669b9c0920ab2c08732f9dc6bc07162c8916c5c5361cac514b06c44fd5a781cd9e
-  data.tar.gz: 4080d919a8b2acc3b6dff84cace90799f13159705d2bda7aff567586bdaea982a8b5dcabb161f9b3e26d959119ce481a8821a1e830d35ec3e2508ac7714df63f
+  metadata.gz: 329163b7405a290722f3e594548eaebf459dbfd01d0a5727030b6272043088dc99b2a3acf455b9f40fa4174084b4f37bb17db3da767862ef457ef7a6d8fe2592
+  data.tar.gz: 34dcf33d3e285be6f08c94eba94ea10845f7204eb3fc6247744e16c0377c6ff6f13d75c83f79d17bc247094fc1cf468492a21432f1c72e246e82dc660165d6cd

data/Gemfile.lock

@@ -1,37 +1,37 @@
 PATH
   remote: .
   specs:
-    graphql-result_cache (0.1.8)
-      graphql (~> 1.9)
+    graphql-result_cache (1.0.0)
+      graphql (~> 1.10)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    diff-lcs (1.3)
-    graphql (1.9.12)
-    rake (13.0.1)
-    rspec (3.8.0)
-      rspec-core (~> 3.8.0)
-      rspec-expectations (~> 3.8.0)
-      rspec-mocks (~> 3.8.0)
-    rspec-core (3.8.2)
-      rspec-support (~> 3.8.0)
-    rspec-expectations (3.8.4)
+    diff-lcs (1.4.4)
+    graphql (1.12.20)
+    rake (12.3.3)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-mocks (3.8.1)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.2)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-support (3.8.2)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.3)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  bundler (>= 2.2.10)
+  bundler (~> 2.2, >= 2.2.10)
   graphql-result_cache!
-  rake (>= 12.3.3)
-  rspec (~> 3.0)
+  rake (~> 12.3, >= 12.3.3)
+  rspec (~> 3.10)
 
 BUNDLED WITH
    2.2.31

data/README.md

@@ -2,6 +2,8 @@
 
 This gem is to cache the json result, instead of resolved object.
 
+If you are using `graphql < 1.10.0` or without `GraphQL::Execution::Interpreter`, please [read this](https://github.com/saharaying/graphql-result_cache/wiki/GraphQL::ResultCache-(v0.1.x)).
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -21,65 +23,57 @@ Or install it yourself as:
 ## Usage
 
 1. Use `GraphQL::ResultCache` as a plugin in your schema.
- 
+
 ```ruby
 class MySchema < GraphQL::Schema
+  # Default value for graphql v1.12.x
+  use GraphQL::Execution::Interpreter
+  use GraphQL::Analysis::AST
+
+  introspection GraphQL::ResultCache::Introspection
+
   mutation Types::MutationType
   query Types::QueryType
- 
+
   use GraphQL::ResultCache
 end
 ```
 
-2. Add the custom field class to accept `result_cache` metadata.
+2. Add the custom field class to accept `result_cache` definition.
 
 ```ruby
 module Types
   class BaseObject < GraphQL::Schema::Object
-    field_class GraphQL::ResultCache::Field
+    field_class GraphQL::ResultCache::Schema::Field
   end
 end
 ```
 
-3. Config the fields which need to be cached with `result_cache` definition.
+3. Config the fields which need to be cached.
 
 ```ruby
 field :theme, Types::ThemeType, null: false, result_cache: true
 ```
 
-4. Wrap query result with `GraphQL::ResultCache::Result`.
-
-```ruby
-class GraphqlController < ApplicationController
-  def execute
-    # ...
-    result = if params[:_json]
-               multiple_execute(params[:_json], context: context)
-             else
-               execute_query(context: context)
-             end
-    render json: GraphQL::ResultCache::Result.new(result)
-  end
-end
-```
-
 ## Result Cache Customization
 
 ### Cache condition
 
+The `if` condition can be either a Symbol or a Proc.
+
 ```ruby
 field :theme, Types::ThemeType, null: false, result_cache: { if: :published? }
 ```
-The `if` condition can be either a Symbol or a Proc.
 
 ### Customized cache key
 
-By default, `GraphQL::ResultCache` will generate a cache key combining the field path, arguments and object. 
+By default, `GraphQL::ResultCache` will generate a cache key combining the field path, arguments and object.
 But you can customize the object clause by specify the `key` option.
 
 ```ruby
 field :theme, Types::ThemeType, null: false, result_cache: { key: :theme_cache_key }
 ```
+
 The `key` can be either a Symbol or a Proc.
 
 ### Callback after cached result applied
@@ -114,7 +108,7 @@ end
 When using with introspection, you need to assign custom introspection to avoid getting the nullable type for a non-null type.
 ```ruby
 class MySchema < GraphQL::Schema
-  introspection ::GraphQL::ResultCache::Introspection
+  introspection GraphQL::ResultCache::Introspection
 end
 ```
 

data/graphql-result_cache.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   spec.email         = ['saharaying@gmail.com']
 
   spec.summary       = 'A result caching plugin for graphql-ruby'
-  spec.description   = 'A result caching plugin for graphql-ruby'
+  spec.description   = 'This gem is to cache the json result, instead of resolved object.'
   spec.homepage      = 'https://github.com/saharaying/graphql-result_cache'
   spec.license       = 'MIT'
 
@@ -19,11 +19,11 @@ Gem::Specification.new do |spec|
   end
   spec.require_paths = ['lib']
 
-  spec.add_development_dependency 'bundler', '>= 2.2.10'
-  spec.add_development_dependency 'rake', '>= 12.3.3'
-  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'bundler', '~> 2.2', '>= 2.2.10'
+  spec.add_development_dependency 'rake', '~> 12.3', '>= 12.3.3'
+  spec.add_development_dependency 'rspec', '~> 3.10'
 
-  spec.add_dependency 'graphql', '~> 1.9'
+  spec.add_dependency 'graphql', '~> 1.10'
 
   # graphql v1.9 requires ruby >= 2.2.0
   spec.required_ruby_version = '>= 2.2.0'

data/lib/graphql/result_cache/callback.rb

@@ -1,21 +1,27 @@
 module GraphQL
   module ResultCache
     class Callback
-      def initialize obj:, args:, ctx:, value:
+      def initialize(obj:, args:, ctx:, value:)
         @obj = obj
         @args = args
         @ctx = ctx
         @value = value
       end
 
-      def call result_hash
+      def call(result_hash)
         case @value
           when Symbol
             @obj.public_send(@value, result_hash)
           when Proc
             @value.call(result_hash, @obj, @args, @ctx)
         end
-        ::GraphQL::ResultCache.logger && ::GraphQL::ResultCache.logger.debug("GraphQL result cache callback called for #{@ctx.path.join('.')}")
+        ::GraphQL::ResultCache.logger && ::GraphQL::ResultCache.logger.debug("GraphQL result cache callback called for #{ctx_path}")
+      end
+
+      private
+
+      def ctx_path
+        @ctx.namespace(:interpreter)[:current_path].join('.')
       end
     end
   end

data/lib/graphql/result_cache/context_config.rb

@@ -8,16 +8,16 @@ module GraphQL
         @value = {}
       end
 
-      def add context:, key:, after_process: nil
-        @value[context.query] ||= []
+      def add query:, path:, key:, after_process: nil
+        @value[query] ||= []
         cached = cache.exist? key
         logger && logger.info("GraphQL result cache key #{cached ? 'hit' : 'miss'}: #{key}")
-        config_value = { path: context.path, key: key }
+        config_value = { path: path, key: key }
         if cached
           config_value[:result] = cache.read(key)
           config_value[:after_process] = after_process if after_process
         end
-        @value[context.query] << config_value
+        @value[query] << config_value
         cached
       end
 

data/lib/graphql/result_cache/introspection/field_type.rb

@@ -4,7 +4,8 @@ module GraphQL
       class FieldType < ::GraphQL::Introspection::FieldType
 
         def type
-          @object.metadata[:original_non_null] && !@object.type.non_null? ? @object.type.to_non_null_type : @object.type
+          return @object.type unless @object.respond_to?(:original_return_type_not_null)
+          @object.original_return_type_not_null && !@object.type.non_null? ? @object.type.to_non_null_type : @object.type
         end
 
       end

data/lib/graphql/result_cache/key.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module GraphQL
   module ResultCache
     class Key
-      def initialize obj:, args:, ctx:, key: nil
+      def initialize(obj:, args:, ctx: nil, key: nil)
         @obj = obj
         @args = args
         @ctx = ctx
@@ -21,7 +23,7 @@ module GraphQL
       private
 
       def path_clause
-        @ctx.path.join('.')
+        @ctx.namespace(:interpreter)[:current_path].join('.') unless @ctx.nil?
       end
 
       def args_clause
@@ -53,7 +55,6 @@ module GraphQL
         return object.id if object.respond_to?(:id)
         object.object_id
       end
-
     end
   end
-end
+end

data/lib/graphql/result_cache/result.rb

@@ -1,27 +1,24 @@
 module GraphQL
   module ResultCache
     class Result
-      extend Forwardable
-
-      attr_reader :value
-
-      def_delegators :@value, :to_json, :as_json
-
       def initialize query_result
         @_result = query_result
-        @value = process_with_result_cache
+      end
+
+      def process!
+        process_with_result_cache
       end
 
       private
 
       def process_with_result_cache
         return process_each(@_result) unless @_result.is_a?(Array)
-        @_result.map { |result| process_each(result) }
+        @_result.each { |result| process_each(result) }
       end
 
       def process_each result
         result_cache_config = result.query.context[:result_cache]
-        blank?(result_cache_config) ? result : result_cache_config.process(result)
+        result_cache_config.process(result) unless blank?(result_cache_config)
       end
 
       def blank? obj

data/lib/graphql/result_cache/schema/field.rb

@@ -0,0 +1,19 @@
+module GraphQL
+  module ResultCache
+    module Schema
+      class Field < ::GraphQL::Schema::Field
+        attr_reader :original_return_type_not_null
+
+        def initialize(*args, result_cache: nil, **kwargs, &block)
+          super(*args, **kwargs, &block)
+          return unless result_cache
+          unless @return_type_null
+            @original_return_type_not_null = true
+            @return_type_null = true
+          end
+          extension FieldExtension, result_cache
+        end
+      end
+    end
+  end
+end

data/lib/graphql/result_cache/schema/field_extension.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'graphql/result_cache/condition'
+require 'graphql/result_cache/context_config'
+require 'graphql/result_cache/key'
+require 'graphql/result_cache/callback'
+
+module GraphQL
+  module ResultCache
+    module Schema
+      class FieldExtension < GraphQL::Schema::FieldExtension
+        def resolve(object:, arguments:, context:)
+          cache_config = options.respond_to?(:to_h) ? options.to_h : {}
+
+          if Condition.new(cache_config, obj: object, args: arguments, ctx: context).true?
+            context[:result_cache] ||= ContextConfig.new
+            cached = add_to_context_result_cache(context, object, arguments, cache_config)
+          end
+
+          yield(object, arguments) unless cached
+        end
+
+        private
+
+        def add_to_context_result_cache(context, object, arguments, cache_config)
+          cache_key = key(object, arguments, context, cache_config)
+          after_process = after_process(object, arguments, context, cache_config)
+          context[:result_cache].add(
+            query: context.query,
+            path: context.namespace(:interpreter)[:current_path],
+            key: cache_key.to_s,
+            after_process: after_process
+          )
+        end
+
+        def key(object, arguments, context, config)
+          Key.new(
+            obj: object,
+            args: arguments,
+            ctx: context,
+            key: config[:key]
+          )
+        end
+
+        def after_process(object, arguments, context, config)
+          return unless config[:after_process]
+
+          Callback.new(
+            obj: object,
+            args: arguments,
+            ctx: context,
+            value: config[:after_process]
+          )
+        end
+      end
+    end
+  end
+end

data/lib/graphql/result_cache/schema/query_instrument.rb

@@ -0,0 +1,15 @@
+module GraphQL
+  module ResultCache
+    module Schema
+      module QueryInstrument
+        module_function
+
+        def before_query(_query) end
+
+        def after_query(query)
+          GraphQL::ResultCache::Result.new(query.result).process!
+        end
+      end
+    end
+  end
+end

data/lib/graphql/result_cache/version.rb

@@ -1,5 +1,5 @@
 module GraphQL
   module ResultCache
-    VERSION = '0.1.8'
+    VERSION = '1.0.0'
   end
 end

data/lib/graphql/result_cache.rb

@@ -1,8 +1,9 @@
 require 'graphql'
 require 'graphql/result_cache/version'
-require 'graphql/result_cache/field'
 require 'graphql/result_cache/result'
-require 'graphql/result_cache/field_instrument'
+require 'graphql/result_cache/schema/field'
+require 'graphql/result_cache/schema/field_extension'
+require 'graphql/result_cache/schema/query_instrument'
 require 'graphql/result_cache/introspection'
 
 module GraphQL
@@ -31,15 +32,16 @@ module GraphQL
       def configure
         yield self
       end
+
+      def use(schema_def)
+        return schema_def.instrument(:query, Schema::QueryInstrument) if schema_def.interpreter?
+        raise 'Please use the graphql gem version >= 1.10 with GraphQL::Execution::Interpreter'
+      end
     end
 
     # Default configuration
-    @expires_in = 3600              # 1.hour
+    @expires_in = 3600 # 1.hour
     @namespace = 'GraphQL:Result'
-
-    def self.use(schema_def, options: {})
-      schema_def.instrument(:field, ::GraphQL::ResultCache::FieldInstrument.new)
-    end
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: graphql-result_cache
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 1.0.0
 platform: ruby
 authors:
 - Ying Fu
@@ -14,6 +14,9 @@ dependencies:
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.2.10
@@ -21,6 +24,9 @@ dependencies:
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.2.10
@@ -28,6 +34,9 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
     - - ">="
       - !ruby/object:Gem::Version
         version: 12.3.3
@@ -35,6 +44,9 @@ dependencies:
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
     - - ">="
       - !ruby/object:Gem::Version
         version: 12.3.3
@@ -44,36 +56,35 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.10'
 - !ruby/object:Gem::Dependency
   name: graphql
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.9'
+        version: '1.10'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.9'
-description: A result caching plugin for graphql-ruby
+        version: '1.10'
+description: This gem is to cache the json result, instead of resolved object.
 email:
 - saharaying@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".github/workflows/gem-push.yml"
 - ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".rspec"
@@ -90,13 +101,14 @@ files:
 - lib/graphql/result_cache/callback.rb
 - lib/graphql/result_cache/condition.rb
 - lib/graphql/result_cache/context_config.rb
-- lib/graphql/result_cache/field.rb
-- lib/graphql/result_cache/field_instrument.rb
 - lib/graphql/result_cache/introspection.rb
 - lib/graphql/result_cache/introspection/field_type.rb
 - lib/graphql/result_cache/key.rb
 - lib/graphql/result_cache/rails.rb
 - lib/graphql/result_cache/result.rb
+- lib/graphql/result_cache/schema/field.rb
+- lib/graphql/result_cache/schema/field_extension.rb
+- lib/graphql/result_cache/schema/query_instrument.rb
 - lib/graphql/result_cache/version.rb
 homepage: https://github.com/saharaying/graphql-result_cache
 licenses:

data/.github/workflows/gem-push.yml

@@ -1,45 +0,0 @@
-name: Ruby Gem
-
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    branches: [ master ]
-
-jobs:
-  build:
-    name: Build + Publish
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      packages: write
-
-    steps:
-    - uses: actions/checkout@v2
-    - name: Set up Ruby 2.6
-      uses: ruby/setup-ruby@473e4d8fe5dd94ee328fdfca9f8c9c7afc9dae5e
-      with:
-        ruby-version: 2.6.6
-
-    - name: Publish to GPR
-      run: |
-        mkdir -p $HOME/.gem
-        touch $HOME/.gem/credentials
-        chmod 0600 $HOME/.gem/credentials
-        printf -- "---\n:github: ${GEM_HOST_API_KEY}\n" > $HOME/.gem/credentials
-        gem build *.gemspec
-        gem push --KEY github --host https://rubygems.pkg.github.com/${OWNER} *.gem
-      env:
-        GEM_HOST_API_KEY: "Bearer ${{secrets.GITHUB_TOKEN}}"
-        OWNER: ${{ github.repository_owner }}
-
-    - name: Publish to RubyGems
-      run: |
-        mkdir -p $HOME/.gem
-        touch $HOME/.gem/credentials
-        chmod 0600 $HOME/.gem/credentials
-        printf -- "---\n:rubygems_api_key: ${GEM_HOST_API_KEY}\n" > $HOME/.gem/credentials
-        gem build *.gemspec
-        gem push *.gem
-      env:
-        GEM_HOST_API_KEY: "${{secrets.RUBYGEMS_AUTH_TOKEN}}"

data/lib/graphql/result_cache/field.rb

@@ -1,17 +0,0 @@
-module GraphQL
-  module ResultCache
-    class Field < ::GraphQL::Schema::Field
-      def initialize(*args, result_cache: nil, **kwargs, &block)
-        @result_cache_config = result_cache
-        super(*args, **kwargs, &block)
-      end
-
-      def to_graphql
-        field_defn = super # Returns a GraphQL::Field
-        field_defn.metadata[:result_cache] = @result_cache_config
-        field_defn.metadata[:original_non_null] = true if @result_cache_config && field_defn.type.non_null?
-        field_defn
-      end
-    end
-  end
-end

data/lib/graphql/result_cache/field_instrument.rb

@@ -1,37 +0,0 @@
-require 'graphql/result_cache/condition'
-require 'graphql/result_cache/context_config'
-require 'graphql/result_cache/key'
-require 'graphql/result_cache/callback'
-
-module GraphQL
-  module ResultCache
-    class FieldInstrument
-      def instrument _type, field
-        return field unless field.metadata[:result_cache]
-
-        cached_resolve_proc = cached_resolve(field)
-        field.redefine do
-          resolve(cached_resolve_proc)
-          type(field.type.of_type) if field.type.non_null?
-        end
-      end
-
-      private
-
-      def cached_resolve field
-        old_resolve_proc = field.resolve_proc
-        cache_config = field.metadata[:result_cache]
-        cache_config = {} unless cache_config.is_a?(Hash)
-        lambda do |obj, args, ctx|
-          if Condition.new(cache_config, obj: obj, args: args, ctx: ctx).true?
-            ctx[:result_cache] ||= ContextConfig.new
-            cache_key = Key.new(obj: obj, args: args, ctx: ctx, key: cache_config[:key])
-            after_process = Callback.new(obj: obj, args: args, ctx: ctx, value: cache_config[:after_process]) if cache_config[:after_process]
-            cached = ctx[:result_cache].add context: ctx, key: cache_key.to_s, after_process: after_process
-          end
-          old_resolve_proc.call(obj, args, ctx) unless cached
-        end
-      end
-    end
-  end
-end