smart_cache_tenant 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a93f98aff4e2b9f648df7da645a638e272db90a42b4953fbf5496b9046f5f56a
+  data.tar.gz: 05bf862690128e59b1f154f272d1761ce9da8cdb156796b5dc782c2932081490
+SHA512:
+  metadata.gz: 51849b0dcec7fd037cb92e0900159cd23da5dce5732b2f5bb562b367878bc8b0c7608e3b5038c9b0767f5b7dafa08d5c80651d886165ebd1b677a5521589731b
+  data.tar.gz: cd03d5da66ff96284e1c83effe0c8897acd2443dbb5839cf421d02b439207bca2feefde5f70af23b8314910d313cfd89b6f2304f3e0acf2715017f8e391af0af

data/.ruby-version

@@ -0,0 +1 @@
+3.3.0

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+## [Unreleased]
+
+## [0.2.0] - 2026-05-01
+
+- Added all features and improvements for the first major release.
+
+## [0.1.0] - 2026-05-01
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Henrique A. Shiraishi
+
+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,270 @@
+# SmartCacheTenant
+
+[![Gem Version](https://badge.fury.io/rb/smart_cache_tenant.svg)](https://badge.fury.io/rb/smart_cache_tenant)
+
+SmartCacheTenant adds tenant-aware query caching on top of `ActiveRecord` by storing cached read results in `Rails.cache` and invalidating them through lightweight version keys.
+
+The gem is designed for multi-tenant Rails applications where the same models are queried repeatedly per tenant and cache invalidation must stay predictable.
+
+## Installation
+
+Add the gem to your application:
+
+```ruby
+gem 'smart_cache_tenant'
+```
+
+Then install it:
+
+```bash
+bundle install
+```
+
+If you are not using Bundler:
+
+```bash
+gem install smart_cache_tenant
+```
+
+## Configuration
+
+Create the initializer below:
+
+```ruby
+# config/initializers/smart_cache_tenant.rb
+SmartCacheTenant.configure do |config|
+	config.enabled = true
+	config.ttl = 1.hour
+	config.tenant_column = :tenant_id
+	config.log_queries = !Rails.env.production?
+end
+```
+
+### What each setting does
+
+`config.enabled`
+
+Globally enables or disables the gem. When it is `false`, relations run normally without cache reads or writes.
+
+`config.ttl`
+
+Defines how long cached query entries and internal version keys stay in `Rails.cache`. The default is `1.hour`.
+
+`config.tenant_column`
+
+Defines which column identifies the tenant, such as `:tenant_id` or `:account_id`.
+
+This value is used in two places:
+
+1. To build tenant-scoped version keys.
+2. To resolve the current tenant from relation filters or bulk write payloads.
+
+If this is not configured, the gem still works, but cache invalidation becomes global per model instead of per tenant.
+
+`config.log_queries`
+
+Enables debug logging for cache hits. When enabled, the gem logs cached operations and their SQL through `Rails.logger`.
+
+In practice, logs are only emitted when all of the following are true:
+
+1. `config.log_queries` is `true`.
+2. `Rails.logger.debug?` is `true`.
+3. The environment is not production.
+
+## Application Setup
+
+### 1. Include callbacks in `ApplicationRecord`
+
+Add the callback module once so write operations can bump the model version after commit:
+
+```ruby
+# app/models/application_record.rb
+class ApplicationRecord < ActiveRecord::Base
+	primary_abstract_class
+
+	include SmartCacheTenant::ModelCallbacks
+end
+```
+
+This is required because the gem invalidates cached reads by updating a version token after records are committed.
+
+### 2. Enable caching per model
+
+Add `has_smart_cache` only to models that should participate in this cache mechanism:
+
+```ruby
+class Project < ApplicationRecord
+	has_smart_cache
+end
+```
+
+Only models marked with `has_smart_cache` are considered cache-enabled.
+
+## How It Works
+
+For cacheable reads, the gem generates a cache key from:
+
+1. The current database name.
+2. The SQL generated by the relation.
+3. The current tenant identifier.
+4. A version token for each model involved in the query.
+5. The operation being executed, such as `load`, `calculate`, or `exists?`.
+
+Instead of deleting cached query keys directly, the gem updates model version keys in `Rails.cache`. Once a version changes, all future reads produce a different cache key and the old cached entry becomes stale naturally.
+
+This keeps invalidation simple and avoids tracking every query key that has ever been generated.
+
+## Cached Operations
+
+The gem currently caches the following relation operations when smart cache is enabled:
+
+1. Record loading through relation `load`.
+2. Aggregate calculations through `calculate`, including helpers such as `count`, `sum`, `average`, `minimum`, and `maximum`.
+3. Existence checks through `exists?`.
+
+If a relation is not cache-enabled, execution falls back to the default ActiveRecord behavior.
+
+## Invalidation Behavior
+
+### Normal model writes
+
+When a model includes `SmartCacheTenant::ModelCallbacks` and declares `has_smart_cache`, the gem bumps that model version on `after_commit`.
+
+That means create, update, and destroy operations invalidate future cached reads for the corresponding tenant.
+
+### Bulk writes
+
+The gem also bumps versions for bulk write operations:
+
+1. `insert_all`
+2. `upsert_all`
+3. `update_all`
+
+For bulk inserts and upserts, the gem tries to extract tenant IDs from the payload using `config.tenant_column`.
+
+For `update_all`, the gem tries to infer the tenant from the relation filters.
+
+If no tenant can be determined, the gem falls back to a model-wide version bump.
+
+## Usage Examples
+
+### Basic setup
+
+```ruby
+class ApplicationRecord < ActiveRecord::Base
+	primary_abstract_class
+
+	include SmartCacheTenant::ModelCallbacks
+end
+
+class Project < ApplicationRecord
+	has_smart_cache
+end
+```
+
+### Tenant-scoped reads
+
+```ruby
+Project.where(tenant_id: current_tenant.id, active: true).to_a
+```
+
+On the first execution, Rails hits the database and stores the loaded records in `Rails.cache`.
+
+On the next execution with the same SQL and the same tenant version, the gem returns the cached records.
+
+### Aggregate queries
+
+```ruby
+Project.where(tenant_id: current_tenant.id).count
+Project.where(tenant_id: current_tenant.id).sum(:budget_cents)
+```
+
+These calculations are cached independently from loaded records because the cache key also includes the operation name.
+
+### Existence checks
+
+```ruby
+Project.where(tenant_id: current_tenant.id, slug: params[:slug]).exists?
+```
+
+The boolean result is cached using the relation SQL, tenant, and model version.
+
+### Automatic invalidation after commit
+
+```ruby
+project = Project.create!(tenant_id: current_tenant.id, name: 'Alpha')
+project.update!(name: 'Beta')
+project.destroy!
+```
+
+Each committed write bumps the cached version for `Project` and the current tenant, so subsequent reads use a new cache key.
+
+### Bulk writes
+
+```ruby
+Project.insert_all([
+	{ tenant_id: 1, name: 'Alpha' },
+	{ tenant_id: 1, name: 'Beta' }
+])
+
+Project.where(tenant_id: 1).update_all(active: false)
+```
+
+These operations also bump the version and invalidate future cached reads.
+
+## Query Scope and Multi-Model Reads
+
+The gem tracks the main relation model and also inspects association-based query loading such as:
+
+1. `joins`
+2. `left_outer_joins`
+3. `includes`
+4. `eager_load`
+
+When associations are resolved through ActiveRecord reflections, the cache key includes version tokens for all involved models.
+
+This means a query like the one below can be invalidated by changes in either model, as long as both are cache-enabled and reachable through association metadata:
+
+```ruby
+Project.includes(:tasks).where(tenant_id: current_tenant.id).to_a
+```
+
+## Logging Cache Hits
+
+When `config.log_queries` is enabled, cache hits are logged in debug mode with:
+
+1. The operation name.
+2. The elapsed lookup time.
+3. The generated SQL.
+
+This is useful during rollout to confirm which queries are being served from cache.
+
+## Notes and Operational Guidance
+
+1. The gem depends on a configured `Rails.cache` backend. Use an appropriate production cache store such as Redis or Memcached.
+2. Tenant scoping is strongest when all relevant queries explicitly filter by the configured tenant column.
+3. If a query does not expose the tenant in a way the relation can resolve, invalidation may fall back to a broader model-level version bump.
+4. Because cached records are stored directly from the relation load result, use this gem only when your cache backend and application lifecycle are compatible with caching ActiveRecord result objects.
+
+## Recommended Integration Checklist
+
+1. Add `gem 'smart_cache_tenant'` to your Gemfile.
+2. Create `config/initializers/smart_cache_tenant.rb` and configure `enabled`, `ttl`, `tenant_column`, and `log_queries`.
+3. Add `include SmartCacheTenant::ModelCallbacks` to `ApplicationRecord`.
+4. Add `has_smart_cache` to each model that should participate in caching.
+5. Confirm that your queries are tenant-scoped using the configured tenant column.
+6. Verify that your `Rails.cache` backend is shared and persistent enough for your environment.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. 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 the created tag, 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/henriqueshiraishi/smart_cache_tenant.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+task default: %i[]

data/lib/smart_cache_tenant/cacheable_persistence.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module SmartCacheTenant
+  module CacheablePersistence
+    def insert_all(attributes, returning: nil, unique_by: nil, record_timestamps: nil)
+      result = super
+      bump_smart_cache_for_class_bulk_write!(attributes)
+      result
+    end
+
+    def upsert_all(attributes, on_duplicate: :update, update_only: nil, returning: nil, unique_by: nil, record_timestamps: nil)
+      result = super
+      bump_smart_cache_for_class_bulk_write!(attributes)
+      result
+    end
+
+    private
+
+    def bump_smart_cache_for_class_bulk_write!(attributes)
+      return unless try(:smart_cache_enabled?)
+      return if attributes.blank?
+
+      tenant_column = SmartCacheTenant.config.tenant_column
+      tenant_ids = Array(attributes).filter_map do |row|
+        next unless row.respond_to?(:[])
+        next if tenant_column.blank?
+
+        row[tenant_column] || row[tenant_column.to_sym] || row[tenant_column.to_s]
+      end.compact.uniq
+
+      if tenant_ids.empty?
+        SmartCacheTenant::VersionStore.bump!(self)
+      else
+        tenant_ids.each { |tenant_id| SmartCacheTenant::VersionStore.bump!(self, tenant_id) }
+      end
+    end
+  end
+end

data/lib/smart_cache_tenant/cacheable_relation.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+module SmartCacheTenant
+  module CacheableRelation
+    def load(&block)
+      return super unless smart_cache_enabled?
+
+      key = smart_cache_key(operation: :load)
+      started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      cached = Rails.cache.read(key)
+
+      unless cached.nil?
+        @records = cached
+        @loaded = true
+        SmartCacheTenant::Logger.log_cache_hit("#{klass.name} Load", elapsed_ms(started), arel_to_sql)
+        return self
+      end
+
+      super.tap do
+        Rails.cache.write(key, @records, expires_in: SmartCacheTenant.config.ttl)
+      end
+    end
+
+    def calculate(operation, column_name)
+      return super unless smart_cache_enabled?
+
+      key = smart_cache_key(operation: "calculate:#{operation}:#{column_name}")
+      started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      cached = Rails.cache.read(key)
+
+      unless cached.nil?
+        SmartCacheTenant::Logger.log_cache_hit("#{klass.name} #{operation.to_s.capitalize}", elapsed_ms(started), arel_to_sql)
+        return cached
+      end
+
+      super.tap do |result|
+        Rails.cache.write(key, result, expires_in: SmartCacheTenant.config.ttl)
+      end
+    end
+
+    def exists?(conditions = :none)
+      return super unless smart_cache_enabled?
+
+      key = smart_cache_key(operation: "exists:#{conditions.inspect}")
+      started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      cached = Rails.cache.read(key)
+
+      unless cached.nil?
+        SmartCacheTenant::Logger.log_cache_hit("#{klass.name} Exists?", elapsed_ms(started), arel_to_sql)
+        return cached
+      end
+
+      super.tap do |result|
+        Rails.cache.write(key, result, expires_in: SmartCacheTenant.config.ttl)
+      end
+    end
+
+    def update_all(updates)
+      result = super
+      bump_smart_cache_for_bulk_write!(affected_rows: result)
+      result
+    end
+
+    def insert_all(attributes, returning: nil, unique_by: nil, record_timestamps: nil)
+      result = super
+      bump_smart_cache_for_bulk_write!(tenant_ids: tenant_ids_from_bulk_attributes(attributes)) if attributes.present?
+      result
+    end
+
+    def upsert_all(attributes, on_duplicate: :update, update_only: nil, returning: nil, unique_by: nil, record_timestamps: nil)
+      result = super
+      bump_smart_cache_for_bulk_write!(tenant_ids: tenant_ids_from_bulk_attributes(attributes)) if attributes.present?
+      result
+    end
+
+    private
+
+    def smart_cache_enabled?
+      SmartCacheTenant.config.enabled && involved_models.all? { |model| model.try(:smart_cache_enabled?) }
+    end
+
+    def smart_cache_key(operation:)
+      versions = involved_models.map do |model|
+        "#{model.table_name}:#{SmartCacheTenant::VersionStore.current(model, resolve_tenant_id)}"
+      end
+
+      payload = {
+        versions: versions.sort,
+        tenant_id: resolve_tenant_id.to_s,
+        sql_fingerprint: arel_to_sql,
+        operation: operation.to_s
+      }
+
+      digest = if defined?(CityHash) && CityHash.respond_to?(:hash128)
+                  CityHash.hash128(payload.to_json)
+                else
+                  Digest::SHA1.hexdigest(payload.to_json)
+                end
+
+      database_name = klass.connection_db_config.database
+      [database_name, 'smart_cache', 'query', digest].join(':').downcase
+    end
+
+    def involved_models
+      @involved_models ||= begin
+        models = [klass]
+
+        if eager_load_values.any? || joins_values.any? || left_outer_joins_values.any? || includes_values.any?
+          all_associations = eager_load_values + joins_values + left_outer_joins_values + includes_values
+          all_associations.each do |association_tree|
+            collect_association_models(klass, association_tree, models)
+          end
+        end
+
+        models.uniq
+      end
+    end
+
+    def collect_association_models(current_model, association_tree, models)
+      case association_tree
+      when Symbol, String
+        add_association_model(current_model, association_tree, models)
+      when Array
+        association_tree.each do |nested_association|
+          collect_association_models(current_model, nested_association, models)
+        end
+      when Hash
+        association_tree.each do |association_name, nested_association|
+          reflection = add_association_model(current_model, association_name, models)
+          next unless reflection
+          collect_association_models(reflection.klass, nested_association, models)
+        end
+      end
+    end
+
+    def add_association_model(current_model, association_name, models)
+      return unless association_name.respond_to?(:to_sym)
+
+      reflection = current_model.reflect_on_association(association_name.to_sym)
+      return unless reflection
+
+      models << reflection.klass
+      reflection
+    end
+
+    def arel_to_sql
+      klass.connection.unprepared_statement { to_sql }
+    end
+
+    def elapsed_ms(started)
+      (Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000.0
+    end
+
+    def resolve_tenant_id
+      tenant_column = SmartCacheTenant.config.tenant_column
+      return if tenant_column.blank?
+
+      where_values_hash[tenant_column.to_s] || where_values_hash["#{klass.table_name}.#{tenant_column}"]
+    rescue StandardError
+      nil
+    end
+
+    def tenant_ids_from_bulk_attributes(attributes)
+      tenant_column = SmartCacheTenant.config.tenant_column
+      return [] if tenant_column.blank?
+
+      Array(attributes).filter_map do |row|
+        next unless row.respond_to?(:[])
+
+        row[tenant_column] || row[tenant_column.to_sym] || row[tenant_column.to_s]
+      end.uniq
+    end
+
+    def bump_smart_cache_for_bulk_write!(tenant_ids: nil, affected_rows: nil)
+      return unless klass.try(:smart_cache_enabled?)
+      return if affected_rows.respond_to?(:zero?) && affected_rows.zero?
+
+      resolved_tenant_ids = Array(tenant_ids).compact
+      resolved_tenant_ids << resolve_tenant_id
+      resolved_tenant_ids = resolved_tenant_ids.compact.uniq
+
+      if resolved_tenant_ids.empty?
+        SmartCacheTenant::VersionStore.bump!(klass)
+      else
+        resolved_tenant_ids.each { |tenant_id| SmartCacheTenant::VersionStore.bump!(klass, tenant_id) }
+      end
+    end
+  end
+end

data/lib/smart_cache_tenant/configuration.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module SmartCacheTenant
+  class Configuration
+    attr_accessor :enabled, :ttl, :tenant_column, :log_queries
+
+    def initialize
+      @enabled = true
+      @ttl = 1.hour
+      @tenant_column = nil
+      @log_queries = !Rails.env.production?
+    end
+  end
+
+  def self.config
+    @config ||= SmartCacheTenant::Configuration.new
+  end
+
+  def self.configure
+    yield config
+  end
+end

data/lib/smart_cache_tenant/model_callbacks.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module SmartCacheTenant
+  module ModelCallbacks
+    extend ActiveSupport::Concern
+
+    included do
+      after_commit :bump_smart_cache_version!
+    end
+
+    class_methods do
+      def smart_cache_enabled?
+        @smart_cache_enabled == true
+      end
+
+      def has_smart_cache
+        @smart_cache_enabled = true
+      end
+
+      def smart_cache_bump!(tenant_id = nil)
+        SmartCacheTenant::VersionStore.bump!(self, tenant_id)
+      end
+
+      def smart_cached_version(tenant_id = nil)
+        SmartCacheTenant::VersionStore.current(self, tenant_id)
+      end
+    end
+
+    def smart_cache_bump!
+      SmartCacheTenant::VersionStore.bump!(self.class, try(SmartCacheTenant.config.tenant_column))
+    end
+
+    private
+
+    def bump_smart_cache_version!
+      return unless self.class.smart_cache_enabled?
+
+      tenant_id = try(SmartCacheTenant.config.tenant_column)
+      SmartCacheTenant::VersionStore.bump!(self.class, tenant_id)
+    end
+  end
+end

data/lib/smart_cache_tenant/railtie.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module SmartCacheTenant
+  class Railtie < Rails::Railtie
+    initializer 'smart_cache.initialize' do
+      ActiveSupport.on_load(:active_record) do
+        ActiveRecord::Relation.prepend(SmartCacheTenant::CacheableRelation)
+        ActiveRecord::Base.singleton_class.prepend(SmartCacheTenant::CacheablePersistence)
+      end
+    end
+  end
+end

data/lib/smart_cache_tenant/smart_cache_logger.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module SmartCacheTenant
+  module Logger
+    RESET  = "\e[0m"
+    BOLD   = "\e[1m"
+    CYAN   = "\e[36m"
+    BLUE   = "\e[34m"
+    YELLOW = "\e[33m"
+
+    def self.log_cache_hit(operation_name, duration_ms, sql)
+      return unless should_log?
+
+      opt_part = colorize("SMART CACHE #{operation_name} (#{format_duration(duration_ms)})", CYAN + BOLD)
+      sql_part = colorize("  #{sql}", BLUE + BOLD)
+
+      Rails.logger.debug("  #{opt_part}#{sql_part}")
+    end
+
+    private
+
+    def self.should_log?
+      SmartCacheTenant.config.log_queries && Rails.logger.debug? && !Rails.env.production?
+    end
+
+    def self.format_duration(ms)
+      if ms >= 1000
+        "#{(ms / 1000.0).round(1)}s"
+      else
+        "#{ms.round(1)}ms"
+      end
+    end
+
+    def self.colorize(text, color_code)
+      if ActiveSupport::LogSubscriber.colorize_logging
+        "#{color_code}#{text}#{RESET}"
+      else
+        text
+      end
+    end
+  end
+end

data/lib/smart_cache_tenant/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SmartCacheTenant
+  VERSION = '0.2.0'
+end

data/lib/smart_cache_tenant/version_store.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module SmartCacheTenant
+  class VersionStore
+    def self.current(model_klass, tenant_id = nil)
+      key = build_key(model_klass, tenant_id)
+      Rails.cache.fetch(key, expires_in: SmartCacheTenant.config.ttl) { generate_version }
+    end
+
+    def self.bump!(model_klass, tenant_id = nil)
+      key = build_key(model_klass, tenant_id)
+      new_version = generate_version
+      Rails.cache.write(key, new_version, expires_in: SmartCacheTenant.config.ttl)
+
+      new_version
+    end
+
+    def self.build_key(model_klass, tenant_id = nil)
+      database_name = model_klass.connection_db_config.database
+      tenant_column = SmartCacheTenant.config.tenant_column
+
+      parts = [database_name, 'smart_cache', 'table_version', model_klass.table_name]
+      parts << "#{tenant_column}:#{tenant_id}" if tenant_id.present? && tenant_column.present?
+      parts.join(':').downcase
+    end
+
+    def self.generate_version
+      Time.zone.now.strftime('%d%m%Y%H%M%S%L')
+    end
+  end
+end

data/lib/smart_cache_tenant.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative 'smart_cache_tenant/cacheable_persistence'
+require_relative 'smart_cache_tenant/cacheable_relation'
+require_relative 'smart_cache_tenant/configuration'
+require_relative 'smart_cache_tenant/model_callbacks'
+require_relative 'smart_cache_tenant/railtie'
+require_relative 'smart_cache_tenant/smart_cache_logger'
+require_relative 'smart_cache_tenant/version_store'
+require_relative "smart_cache_tenant/version"
+
+module SmartCacheTenant
+end

data/sig/smart_cache_tenant.rbs

@@ -0,0 +1,4 @@
+module SmartCacheTenant
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: smart_cache_tenant
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Henrique A. Shiraishi
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-05-01 00:00:00.000000000 Z
+dependencies: []
+description: SmartCacheTenant adds tenant-aware query caching on top of ActiveRecord
+  by storing cached read results in Rails.cache and invalidating them through lightweight
+  version keys.
+email:
+- henriqueashiraishi@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".ruby-version"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/smart_cache_tenant.rb
+- lib/smart_cache_tenant/cacheable_persistence.rb
+- lib/smart_cache_tenant/cacheable_relation.rb
+- lib/smart_cache_tenant/configuration.rb
+- lib/smart_cache_tenant/model_callbacks.rb
+- lib/smart_cache_tenant/railtie.rb
+- lib/smart_cache_tenant/smart_cache_logger.rb
+- lib/smart_cache_tenant/version.rb
+- lib/smart_cache_tenant/version_store.rb
+- sig/smart_cache_tenant.rbs
+homepage: https://github.com/henriqueshiraishi/ruby-smart_cache_tenant
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/henriqueshiraishi/ruby-smart_cache_tenant
+  source_code_uri: https://github.com/henriqueshiraishi/ruby-smart_cache_tenant
+  changelog_uri: https://github.com/henriqueshiraishi/ruby-smart_cache_tenant/blob/main/CHANGELOG.md
+post_install_message:
+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: 3.5.3
+signing_key:
+specification_version: 4
+summary: Tenant-aware query caching for ActiveRecord.
+test_files: []