query_stash 0.1.0

data/sig/query_stash/base.rbs

@@ -0,0 +1,151 @@
+# Generated from lib/query_stash/base.rb with RBS::Inline
+
+module QueryStash
+  class Base
+    # Where `enable!` and `disable!` keep what they set, when no `isolated_state` is
+    # given: a hash in a thread variable, so every fiber of a thread sees the same values and
+    # other threads see none.
+    #
+    # An isolated state is any object that responds to `[]`, `[]=`, `key?` and `delete`, like
+    # `ActiveSupport::IsolatedExecutionState`.
+    class ThreadVariableState
+      THREAD_VARIABLE: Symbol
+
+      # : (untyped key) -> untyped
+      def []: (untyped key) -> untyped
+
+      # : (untyped key, untyped value) -> untyped
+      def []=: (untyped key, untyped value) -> untyped
+
+      # : (untyped key) -> bool
+      def key?: (untyped key) -> bool
+
+      # : (untyped key) -> untyped
+      def delete: (untyped key) -> untyped
+
+      private
+
+      # : () -> Hash[untyped, untyped]
+      def values: () -> Hash[untyped, untyped]
+    end
+
+    # Used when no `instrumenter` is given: runs the block and tells no one.
+    class NullInstrumenter
+      # : (String _name, ?Hash[Symbol, untyped] payload) ?{ (Hash[Symbol, untyped]) -> untyped } -> untyped
+      def instrument: (String _name, ?Hash[Symbol, untyped] payload) ?{ (Hash[Symbol, untyped]) -> untyped } -> untyped
+    end
+
+    # Used when no `error_reporter` is given.
+    class WarnErrorReporter
+      # : (Exception error, ?handled: bool) -> void
+      def report: (Exception error, ?handled: bool) -> void
+    end
+
+    self.@instances: Concurrent::Map[untyped, untyped]
+
+    # : (Class subclass) -> void
+    def self.inherited: (Class subclass) -> void
+
+    # : (untyped app) -> instance
+    def self.[]: (untyped app) -> instance
+
+    # : (untyped app) -> bool
+    def self.key?: (untyped app) -> bool
+
+    # Makes `stash` the instance `app` uses.
+    # : (untyped app, instance stash) -> instance
+    def self.set: (untyped app, instance stash) -> instance
+
+    @adapter: Symbol
+
+    @cache: _CacheStore
+
+    @registry: Registry
+
+    @raise_on_cache_error: bool
+
+    @error_reporter: _ErrorReporter
+
+    @instrumenter: _Instrumenter
+
+    @isolated_state: _IsolatedState
+
+    @enabled: bool
+
+    attr_reader registry: Registry
+
+    attr_reader cache: _CacheStore
+
+    attr_reader enabled: bool
+
+    # What each stash is given:
+    #
+    # - `enabled`: whether queries are stashed outside of `enable!` and `disable!`.
+    # - `isolated_state`: where those keep what they set. By default, a thread variable.
+    # - `instrumenter`: told about what the stash does. By default, no one.
+    # - `error_reporter`: told about the errors it handles. By default, a warning on stderr.
+    # - `raise_on_cache_error`: raise the errors of the cache store, instead of reporting them.
+    # - `cache_store`: where results are kept, any object that responds to `read(key)`,
+    #   `write(key, value, expires_in:)` and `clear`, like an ActiveSupport cache store.
+    #
+    # @rbs cache_store: _CacheStore
+    # @rbs enabled: bool
+    # @rbs isolated_state: _IsolatedState?
+    # @rbs instrumenter: _Instrumenter?
+    # @rbs error_reporter: _ErrorReporter?
+    # @rbs raise_on_cache_error: bool
+    # @rbs return: void
+    def initialize: (cache_store: _CacheStore, ?enabled: bool, ?isolated_state: _IsolatedState?, ?instrumenter: _Instrumenter?, ?error_reporter: _ErrorReporter?, ?raise_on_cache_error: bool) -> void
+
+    # : () { (Registry registry) -> void } -> void
+    def configure: () { (Registry registry) -> void } -> void
+
+    # Turn the stash on or off for the block. Outside of either, it follows `enabled`.
+    # : [T] () { () -> T } -> T
+    def enable!: [T] () { () -> T } -> T
+
+    # : [T] () { () -> T } -> T
+    def disable!: [T] () { () -> T } -> T
+
+    # : (Registry::Rule rule) -> _CacheStore
+    def cache_for: (Registry::Rule rule) -> _CacheStore
+
+    # The rule of the registry the query is to be stashed under, or nil when it isn't to be: the stash is off
+    # (see `stashing?`), the query is not one that can be, or no rule matches it.
+    # : (*untyped) -> Registry::Rule?
+    def rule_for: (*untyped) -> Registry::Rule?
+
+    # The key the query's result is stored under.
+    # : (*untyped) -> String
+    def cache_key_for: (*untyped) -> String
+
+    # The result stored for the query, or nil when there is none (or the cache store failed: that is
+    # reported, or raised when `raise_on_cache_error` is set). Emits `cache_read` and, on a hit,
+    # `cache_hit`.
+    # : (Registry::Rule rule, *untyped args) -> untyped
+    def read: (Registry::Rule rule, *untyped args) -> untyped
+
+    # Stores `result` for the query when the rule keeps results for any time (else it is skipped), and
+    # returns it. Emits `cache_miss` or, when skipped, `cache_skip`.
+    # A failure of the cache store is reported (or raised), and does not lose the result.
+    # : (Registry::Rule rule, untyped result, *untyped args) -> untyped
+    def write: (Registry::Rule rule, untyped result, *untyped args) -> untyped
+
+    private
+
+    # Whether the stash is on for the current execution context: what `enable!` or `disable!` set
+    # there, or else `enabled`.
+    # : () -> bool
+    def stashing?: () -> bool
+
+    # Sets the stash on or off in the isolated state for the block, then puts back what was there.
+    # : [T] (bool value) { () -> T } -> T
+    def isolate: [T] (bool value) { () -> T } -> T
+
+    # : () -> Registry
+    def build_registry: () -> Registry
+
+    # : [T] () { () -> T } -> untyped
+    def rescue_cache_error: [T] () { () -> T } -> untyped
+  end
+end

data/sig/query_stash/mongo.rbs

@@ -0,0 +1,90 @@
+# Generated from lib/query_stash/mongo.rb with RBS::Inline
+
+module QueryStash
+  class Mongo < Base
+    # Has a name: a collection, or a database.
+    interface _Named
+      def name: () -> String
+    end
+
+    # A `Mongo::Collection::View`, or an aggregation view.
+    interface _View
+      def collection: () -> _Named
+
+      def database: () -> _Named
+
+      def filter: () -> untyped
+
+      def options: () -> Hash[Symbol, untyped]
+
+      def each: () ?{ (untyped document) -> untyped } -> untyped
+    end
+
+    # A selector to match rules against.
+    type selector = Hash[Symbol, untyped]
+
+    # ---------------- Constants ----------------
+    # Wildcard sentinel for selector patterns
+    ANY: Object
+
+    class MongoFilterRegistry < Registry
+      private
+
+      # Pattern semantics:
+      #
+      # - ANY sentinel:
+      #     pattern.equal?(ANY) => match anything as long as the key exists
+      # : (untyped actual, untyped pattern) -> bool
+      def value_matches_pattern?: (untyped actual, untyped pattern) -> bool
+    end
+
+    # Enables the stash for the duration of each request. `application` is the Rails application the
+    # middleware stack belongs to; `app` is the next middleware.
+    class Middleware
+      @app: _RackApp
+
+      @application: untyped
+
+      # : (_RackApp app, untyped application) -> void
+      def initialize: (_RackApp app, untyped application) -> void
+
+      # : (Hash[String, untyped] env) -> untyped
+      def call: (Hash[String, untyped] env) -> untyped
+    end
+
+    # @rbs module-self _View
+    module AdapterPatch : _View
+      # : () ?{ (untyped document) -> untyped } -> untyped
+      def each: () ?{ (untyped document) -> untyped } -> untyped
+    end
+
+    # Runs the view's cursor through the stash: `cursor` iterates the view's documents into the block
+    # it is given, and `consumer` is the block `each` was called with. (RBS can't say that a block takes
+    # a block, so the parameters of `cursor` are not typed.)
+    # : (_View view, ?(^(untyped) -> untyped)? consumer) { (?) -> untyped } -> untyped
+    def wrap: (_View view, ?(^(untyped) -> untyped)? consumer) { (?) -> untyped } -> untyped
+
+    # The rule the view is stashed under, or nil when it isn't to be stashed: the stash is off, or no rule
+    # matches its selector.
+    # : (_View view) -> Registry::Rule?
+    def rule_for: (_View view) -> Registry::Rule?
+
+    # Based off of #cache_key from Mongo::QueryCache
+    # https://github.com/mongodb/mongo-ruby-driver/blob/master/lib/mongo/query_cache.rb#L19
+    # : (_View view) -> String
+    def cache_key_for: (_View view) -> String
+
+    private
+
+    # : () -> MongoFilterRegistry
+    def build_registry: () -> MongoFilterRegistry
+
+    # Based off of #cache_options in Mongo::Collection::View::Iterable
+    # https://github.com/mongodb/mongo-ruby-driver/blob/v2.19.3/lib/mongo/collection/view/iterable.rb
+    # : (_View view) -> selector
+    def selector_for: (_View view) -> selector
+
+    # : () { (?) -> untyped } -> Array[untyped]
+    def load_documents: () { (?) -> untyped } -> Array[untyped]
+  end
+end

data/sig/query_stash/railtie.rbs

@@ -0,0 +1,24 @@
+# Generated from lib/query_stash/railtie.rb with RBS::Inline
+
+# The railtie is the only part of QueryStash that expects ActiveSupport: it hands the rest what it
+# needs from it, as options of `config.query_stash`.
+module QueryStash
+  class Railtie < Rails::Railtie
+    # The options an adapter can set for itself, in `config.query_stash.active_record` and
+    # `config.query_stash.mongo`. What it does not set, it takes from `config.query_stash`.
+    ADAPTER_OPTIONS: untyped
+
+    # The adapters' sections of `config.query_stash`, which are not options of their own.
+    ADAPTER_SECTIONS: untyped
+
+    # The `adapter` (QueryStash::ActiveRecord or QueryStash::Mongo) for the app's `config`, with
+    # its own options over the ones of `config.query_stash`, and the cache store they name.
+    # : (singleton(Base) adapter, untyped config) -> Base
+    def self.build: (singleton(Base) adapter, untyped config) -> Base
+
+    # `config.query_stash`, with what the adapter's own section sets on top of it. A section only
+    # holds what the user set, so an option it has, even a `false` or a `nil`, is the user's choice.
+    # : (singleton(Base) adapter, untyped config) -> untyped
+    def self.options_for: (singleton(Base) adapter, untyped config) -> untyped
+  end
+end

data/sig/query_stash/registry/sql.rbs

@@ -0,0 +1,11 @@
+# Generated from lib/query_stash/registry/sql.rb with RBS::Inline
+
+module QueryStash
+  class Registry
+    # The rules of the adapters that stash SQL: a rule's selector is a regexp, matched against the query.
+    class Sql < Registry
+      # @rbs override
+      def add_rule: ...
+    end
+  end
+end

data/sig/query_stash/registry.rbs

@@ -0,0 +1,114 @@
+# Generated from lib/query_stash/registry.rb with RBS::Inline
+
+module QueryStash
+  class Registry
+    # How long a result is kept: a number of seconds, or something that works it out from the result.
+    type ttl = _ToI | ^(untyped result) -> _ToI
+
+    class Rule < Data
+      attr_reader selector(): untyped
+
+      attr_reader name(): String
+
+      attr_reader ttl_seconds(): ttl
+
+      attr_reader ttl_jitter_seconds(): ttl
+
+      attr_reader enabled(): (^() -> boolish)?
+
+      attr_reader store(): _CacheStore?
+
+      def self.new: (untyped selector, String name, ttl ttl_seconds, ttl ttl_jitter_seconds, (^() -> boolish)? enabled, _CacheStore? store) -> instance
+                  | (selector: untyped, name: String, ttl_seconds: ttl, ttl_jitter_seconds: ttl, enabled: (^() -> boolish)?, store: _CacheStore?) -> instance
+
+      def self.members: () -> [ :selector, :name, :ttl_seconds, :ttl_jitter_seconds, :enabled, :store ]
+
+      def members: () -> [ :selector, :name, :ttl_seconds, :ttl_jitter_seconds, :enabled, :store ]
+    end
+
+    class Rule
+      # The seconds a result is kept for, for `result`.
+      # : (untyped result) -> Integer
+      def ttl_seconds_for: (untyped result) -> Integer
+
+      # The jitter added to that, for `result`.
+      # : (untyped result) -> Integer
+      def ttl_jitter_seconds_for: (untyped result) -> Integer
+    end
+
+    # What `set_rule_defaults` can set: the options of `add_rule` other than the selector and the name.
+    RULE_DEFAULTS: Array[Symbol]
+
+    # What an option of `add_rule` is when it is not given (`nil` is a value too: `enabled: nil`).
+    UNSET: Object
+
+    @rules: Array[Rule]
+
+    @rule_defaults: Hash[Symbol, untyped]
+
+    attr_reader rules: Array[Rule]
+
+    # : () -> void
+    def initialize: () -> void
+
+    # Sets what the rules added from now on take for the options they don't give, so that a block of rules
+    # needs to say only what is different about each one:
+    #
+    #   registry.set_rule_defaults(ttl_seconds: 60, ttl_jitter_seconds: 10)
+    #   registry.add_rule(/SELECT .*users/, name: "users")                   # 60 seconds, 10 of jitter
+    #   registry.add_rule(/SELECT .*orders/, name: "orders", ttl_seconds: 5) # 5 seconds, 10 of jitter
+    #
+    # The rules that exist are left as they are. A later call changes only the options it names, and `nil`
+    # takes a default away.
+    #
+    # @rbs **defaults: untyped
+    # @rbs return: Hash[Symbol, untyped]
+    def set_rule_defaults: (**untyped defaults) -> Hash[Symbol, untyped]
+
+    # `ttl_seconds` and `ttl_jitter_seconds` are required, unless `set_rule_defaults` gave them.
+    #
+    # @rbs selector: untyped
+    # @rbs name: String
+    # @rbs ttl_seconds: ttl | Object
+    # @rbs ttl_jitter_seconds: ttl | Object
+    # @rbs enabled: (^() -> boolish)? | Object
+    # @rbs store: _CacheStore? | Object
+    # @rbs return: Array[Rule]
+    def add_rule: (untyped selector, name: String, ?ttl_seconds: ttl | Object, ?ttl_jitter_seconds: ttl | Object, ?enabled: (^() -> boolish)? | Object, ?store: _CacheStore? | Object) -> Array[Rule]
+
+    # : (String name) -> Array[Rule]
+    def delete_rule: (String name) -> Array[Rule]
+
+    # Selector / options / collection-based lookup
+    # : (untyped selector) -> Rule?
+    def match_rule: (untyped selector) -> Rule?
+
+    private
+
+    # Pattern matching for hashes.
+    #
+    # `pattern` is a subset / pattern-form of `full`:
+    # - wildcards and special values are interpreted via value_matches_pattern?
+    #
+    # : (Hash[untyped, untyped] full, Hash[untyped, untyped] pattern) -> bool
+    def hash_matches_pattern?: (Hash[untyped, untyped] full, Hash[untyped, untyped] pattern) -> bool
+
+    # Pattern semantics:
+    #
+    # - Proc:
+    #     pattern.call(actual) must be truthy
+    # - Regexp:
+    #     actual.to_s must match pattern
+    # - Hash:
+    #     pattern is a nested hash pattern, recurse
+    # - Array:
+    #     pattern is a "prefix" array pattern:
+    #       - pattern length <= actual length
+    #       - each element is matched via value_matches_pattern?
+    # - Fallback:
+    #     actual == pattern
+    #
+    # : (untyped actual, untyped pattern) -> bool
+    def value_matches_pattern?: (untyped actual, untyped pattern) -> bool
+  end
+end

data/sig/query_stash/sequel.rbs

@@ -0,0 +1,97 @@
+# Generated from lib/query_stash/sequel.rb with RBS::Inline
+
+module QueryStash
+  # Stashes the `SELECT`s of Sequel datasets, matched by regexp like the ActiveRecord ones.
+  #
+  # A database stashes once it loads the extension, which gives it a stash of its own, from the options in its
+  # `:query_stash` option:
+  #
+  #   DB = Sequel.connect(url, query_stash: { cache_store: store, enabled: true })
+  #   DB.extension(:query_stash)
+  #   QueryStash::Sequel[DB].configure { |rules| ... }
+  #
+  # (`cache_store:` and the options of `QueryStash::Base#initialize`.) With sequel-rails, the railtie makes it
+  # the app's stash instead: `Sequel::Model.db.extension(:query_stash)` is all it takes for another database.
+  #
+  # (Inside this class `Sequel` is this class: the library is `::Sequel`.)
+  class Sequel < Base
+    # A dataset, as far as the patch and the stash look at it.
+    interface _Dataset
+      def fetch_rows: (String sql) { (Hash[Symbol, untyped] row) -> untyped } -> untyped
+
+      def db: () -> ::Sequel::Database
+
+      def opts: () -> Hash[Symbol, untyped]
+
+      def is_a?: (Module mod) -> bool
+    end
+
+    CACHEABLE_SQL_REGEX: Regexp
+
+    # Enables the stash for the duration of each request. `application` is the Rails application the
+    # middleware stack belongs to; `app` is the next middleware.
+    class Middleware
+      @app: _RackApp
+
+      @application: untyped
+
+      # : (_RackApp app, untyped application) -> void
+      def initialize: (_RackApp app, untyped application) -> void
+
+      # : (Hash[String, untyped] env) -> untyped
+      def call: (Hash[String, untyped] env) -> untyped
+    end
+
+    # Included in the dataset class of each database that loads the extension. Every query a dataset runs
+    # goes through `fetch_rows`, which each adapter defines for its own dataset class, so this has to sit
+    # in front of those rather than in `Sequel::Dataset`.
+    #
+    # A database's stash is the one set for the database itself, which the extension does (see
+    # `QueryStash::Sequel.stash_builder`).
+    # @rbs module-self _Dataset
+    module DatasetPatch : _Dataset
+      # : (String sql) { (Hash[Symbol, untyped] row) -> untyped } -> untyped
+      def fetch_rows: (String sql) { (Hash[Symbol, untyped] row) -> untyped } -> untyped
+    end
+
+    # What builds the stash of a database that loads the extension without one: from its `:query_stash`
+    # option. (The railtie replaces it, to hand out the app's stash.)
+    DEFAULT_STASH_BUILDER: ^(::Sequel::Database) -> QueryStash::Sequel
+
+    self.@stash_builder: ^(::Sequel::Database) -> QueryStash::Sequel
+
+    # Builds the stash of a database that loads the extension without having one.
+    # : () -> (^(::Sequel::Database) -> QueryStash::Sequel)
+    def self.stash_builder: () -> ^(::Sequel::Database) -> QueryStash::Sequel
+
+    # : (^(::Sequel::Database) -> QueryStash::Sequel builder) -> void
+    attr_writer stash_builder: untyped
+
+    # Runs the dataset's query through the stash: `cursor` fetches its rows into the block it is given,
+    # and `consumer` is the block `fetch_rows` was called with. (RBS can't say that a block takes a block,
+    # so the parameters of `cursor` are not typed.)
+    # : (_Dataset dataset, String sql, (^(Hash[Symbol, untyped]) -> untyped)? consumer) { (?) -> untyped } -> untyped
+    def wrap: (_Dataset dataset, String sql, (^(Hash[Symbol, untyped]) -> untyped)? consumer) { (?) -> untyped } -> untyped
+
+    # The rule the query is stashed under, or nil when it isn't to be stashed: the stash is off, it has
+    # binds or runs through a cursor (not supported), it is not a SELECT, or no rule matches it.
+    # : (_Dataset dataset, String sql) -> Registry::Rule?
+    def rule_for: (_Dataset dataset, String sql) -> Registry::Rule?
+
+    # The same SQL is not the same query on another database, or on another server of the same one.
+    # : (_Dataset dataset, String sql) -> String
+    def cache_key_for: (_Dataset dataset, String sql) -> String
+
+    private
+
+    # : () -> Registry::Sql
+    def build_registry: () -> Registry::Sql
+
+    # Whether the dataset is a prepared statement, or has bind variables.
+    # : (_Dataset dataset) -> bool
+    def bound?: (_Dataset dataset) -> bool
+
+    # : () { (?) -> untyped } -> Array[Hash[Symbol, untyped]]
+    def load_rows: () { (?) -> untyped } -> Array[Hash[Symbol, untyped]]
+  end
+end

data/sig/query_stash/version.rbs

@@ -0,0 +1,6 @@
+# Generated from lib/query_stash/version.rb with RBS::Inline
+
+module QueryStash
+  # Merging a change to this file into main releases the gem (.github/workflows/release.yml).
+  VERSION: String
+end

data/sig/query_stash.rbs

@@ -0,0 +1,41 @@
+# Generated from lib/query_stash.rb with RBS::Inline
+
+module QueryStash
+  # Where `enable!` and `disable!` keep what they set, like `ActiveSupport::IsolatedExecutionState`.
+  interface _IsolatedState
+    def []: (untyped key) -> untyped
+
+    def []=: (untyped key, untyped value) -> untyped
+
+    def key?: (untyped key) -> bool
+
+    def delete: (untyped key) -> untyped
+  end
+
+  # Where results are kept, like an `ActiveSupport::Cache::Store`. `write` is given `expires_in:`.
+  interface _CacheStore
+    def read: (String key) -> untyped
+
+    def write: (String key, untyped value, ?Hash[Symbol, untyped] options) -> untyped
+
+    def clear: () -> untyped
+  end
+
+  # Told about what the stash does, like `ActiveSupport::Notifications`.
+  interface _Instrumenter
+    def instrument: (String name, ?Hash[Symbol, untyped] payload) ?{ (Hash[Symbol, untyped]) -> untyped } -> untyped
+  end
+
+  # Told about the errors the stash handles, like `ActiveSupport.error_reporter`.
+  interface _ErrorReporter
+    def report: (Exception error, ?handled: bool) -> untyped
+  end
+
+  # The next middleware.
+  interface _RackApp
+    def call: (Hash[String, untyped] env) -> untyped
+  end
+
+  class Error < StandardError
+  end
+end

data/sig/sequel/extensions/query_stash.rbs

@@ -0,0 +1,2 @@
+# Generated from lib/sequel/extensions/query_stash.rb with RBS::Inline
+

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: query_stash
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Persona
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Caches the results of allowlisted SELECT queries (and MongoDB finds)
+  across requests, below the ORM, with per-rule TTLs computed from the result.
+email:
+- rubygems@withpersona.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/query_stash.rb
+- lib/query_stash/active_record.rb
+- lib/query_stash/base.rb
+- lib/query_stash/mongo.rb
+- lib/query_stash/railtie.rb
+- lib/query_stash/registry.rb
+- lib/query_stash/registry/sql.rb
+- lib/query_stash/sequel.rb
+- lib/query_stash/version.rb
+- lib/sequel/extensions/query_stash.rb
+- sig/query_stash.rbs
+- sig/query_stash/active_record.rbs
+- sig/query_stash/base.rbs
+- sig/query_stash/mongo.rbs
+- sig/query_stash/railtie.rbs
+- sig/query_stash/registry.rbs
+- sig/query_stash/registry/sql.rbs
+- sig/query_stash/sequel.rbs
+- sig/query_stash/version.rbs
+- sig/sequel/extensions/query_stash.rbs
+homepage: https://github.com/persona-id/query_stash
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/persona-id/query_stash
+  source_code_uri: https://github.com/persona-id/query_stash
+  changelog_uri: https://github.com/persona-id/query_stash/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: Cross-request, allowlisted query result caching for ActiveRecord and MongoDB.
+test_files: []