solid_cache_mongoid 0.1.0

data/app/models/solid_cache_mongoid/record.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module SolidCacheMongoid
+  module Record
+    extend ActiveSupport::Concern
+    include Mongoid::Document
+    include Mongoid::Timestamps
+    include Mongoid::Locker
+    included do
+      NULL_INSTRUMENTER = ActiveSupport::Notifications::Instrumenter.new(ActiveSupport::Notifications::Fanout.new)
+
+      encrypt_with(key_id: ENV.fetch("SOLID_CACHE_KEY_ENCRYPT", nil) || Rails.application.secret_key_base) if SolidCacheMongoid.configuration.encrypt?
+
+      field :key, type: BSON::Binary, encrypt: SolidCacheMongoid.configuration.encryption_context_properties
+      field :value, type: BSON::Binary, encrypt: SolidCacheMongoid.configuration.encryption_context_properties
+      field :key_hash, type: Integer
+      field :byte_size, type: Integer
+      field :locking_name, type: String
+      field :locked_at, type: Time
+
+      index({ byte_size: 1 })
+      index({ key_hash: 1, byte_size: 1 })
+      index({ key_hash: 1 }, { unique: true })
+
+      store_in collection: SolidCacheMongoid.configuration.collection if SolidCacheMongoid.configuration.collection.present?
+      store_in client: SolidCacheMongoid.configuration.client if SolidCacheMongoid.configuration.client.present?
+      store_in database: SolidCacheMongoid.configuration.database if SolidCacheMongoid.configuration.database.present?
+    end
+
+    class_methods do
+      def disable_instrumentation(&block)
+        with_instrumenter(NULL_INSTRUMENTER, &block)
+      end
+
+      def with_instrumenter(instrumenter)
+        if ActiveSupport::Notifications.respond_to?(:instrumenter) && ActiveSupport::Notifications.respond_to?(:instrumenter=)
+          old = ActiveSupport::Notifications.instrumenter
+          ActiveSupport::Notifications.instrumenter = instrumenter
+          begin
+            yield
+          ensure
+            ActiveSupport::Notifications.instrumenter = old
+          end
+        else
+          # Fallback al comportamiento previo que usaba IsolatedExecutionState
+          old = ActiveSupport::IsolatedExecutionState[:active_record_instrumenter]
+          ActiveSupport::IsolatedExecutionState[:active_record_instrumenter] = instrumenter
+          begin
+            yield
+          ensure
+            ActiveSupport::IsolatedExecutionState[:active_record_instrumenter] = old
+          end
+        end
+      end
+
+      def without_query_cache(&block)
+        Mongo::QueryCache.uncached(&block)
+      end
+      alias :uncached :without_query_cache
+
+      def with_query_cache(&block)
+        Mongo::QueryCache.cache(&block)
+      end
+      alias :cache :with_query_cache
+
+      def lease_connection
+        # Obtiene el cliente Mongo actual del modelo
+        client = self.mongo_client
+
+        # Asegura que hay una conexión disponible
+        client.reconnect unless client.cluster.connected?
+
+        yield client
+      end
+    end
+  end
+end

data/lib/active_support/cache/solid_cache_mongoid_store.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "solid_cache_mongoid"
+
+module ActiveSupport
+  module Cache
+    SolidCacheMongoidStore = SolidCacheMongoid::Store
+  end
+end

data/lib/generators/solid_cache/install/USAGE

@@ -0,0 +1,9 @@
+Description:
+    Installs solid_cache as the Rails cache store
+
+Example:
+    bin/rails generate solid_cache:install
+
+    This will create:
+        Installs the solid_cache migrations
+        Replaces the cache store in envionment configuration

data/lib/generators/solid_cache/install/install_generator.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class SolidCacheMongoid::InstallGenerator < Rails::Generators::Base
+  source_root File.expand_path("templates", __dir__)
+
+  def copy_files
+    template "config/cache.yml"
+  end
+
+  def configure_cache_store_adapter
+    gsub_file Pathname.new(destination_root).join("config/environments/production.rb"),
+      /(# )?config\.cache_store = (:.*)/, "config.cache_store = :solid_cache_mongoid_store"
+
+    gsub_file Pathname.new(destination_root).join("config/environments/development.rb"),
+      /(# )?config\.cache_store = (:.*)/, "config.cache_store = :solid_cache_mongoid_store"
+
+    gsub_file Pathname.new(destination_root).join("config/environments/test.rb"),
+      /(# )?config\.cache_store = (:.*)/, "config.cache_store = :solid_cache_mongoid_store"
+  end
+end

data/lib/generators/solid_cache/install/templates/config/cache.yml.tt

@@ -0,0 +1,20 @@
+default: &default
+  # database: <%= ENV.fetch("SOLID_CACHE_DATABASE", "solid_cache") %>
+  # collection: solid_cache_entries
+  # client: default
+  # encrypt: false
+  store_options:
+    # Cap age of oldest cache entry to fulfill retention policies
+    # max_age: <%%= 60.days.to_i %>
+    max_size: <%%= 256.megabytes %>
+    namespace: <%%= Rails.env %>
+
+development:
+  <<: *default
+
+test:
+  <<: *default
+
+production:
+  database: <%= ENV.fetch("SOLID_CACHE_DATABASE", "solid_cache") %>
+  <<: *default

data/lib/generators/solid_cache/install/templates/db/cache_schema.rb

@@ -0,0 +1,12 @@
+ActiveRecord::Schema[7.2].define(version: 1) do
+  create_table "solid_cache_entries", force: :cascade do |t|
+    t.binary "key", limit: 1024, null: false
+    t.binary "value", limit: 536870912, null: false
+    t.datetime "created_at", null: false
+    t.integer "key_hash", limit: 8, null: false
+    t.integer "byte_size", limit: 4, null: false
+    t.index ["byte_size"], name: "index_solid_cache_entries_on_byte_size"
+    t.index ["key_hash", "byte_size"], name: "index_solid_cache_entries_on_key_hash_and_byte_size"
+    t.index ["key_hash"], name: "index_solid_cache_entries_on_key_hash", unique: true
+  end
+end

data/lib/generators/solid_cache/install/templates/db/cache_structure.mysql.sql

@@ -0,0 +1,56 @@
+
+/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
+/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
+/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
+/*!50503 SET NAMES utf8mb4 */;
+/*!40103 SET @OLD_TIME_ZONE=@@TIME_ZONE */;
+/*!40103 SET TIME_ZONE='+00:00' */;
+/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
+/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
+/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
+/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;
+DROP TABLE IF EXISTS `ar_internal_metadata`;
+/*!40101 SET @saved_cs_client     = @@character_set_client */;
+/*!50503 SET character_set_client = utf8mb4 */;
+CREATE TABLE `ar_internal_metadata` (
+  `key` varchar(255) NOT NULL,
+  `value` varchar(255) DEFAULT NULL,
+  `created_at` datetime(6) NOT NULL,
+  `updated_at` datetime(6) NOT NULL,
+  PRIMARY KEY (`key`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
+/*!40101 SET character_set_client = @saved_cs_client */;
+DROP TABLE IF EXISTS `schema_migrations`;
+/*!40101 SET @saved_cs_client     = @@character_set_client */;
+/*!50503 SET character_set_client = utf8mb4 */;
+CREATE TABLE `schema_migrations` (
+  `version` varchar(255) NOT NULL,
+  PRIMARY KEY (`version`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
+/*!40101 SET character_set_client = @saved_cs_client */;
+DROP TABLE IF EXISTS `solid_cache_entries`;
+/*!40101 SET @saved_cs_client     = @@character_set_client */;
+/*!50503 SET character_set_client = utf8mb4 */;
+CREATE TABLE `solid_cache_entries` (
+  `id` bigint NOT NULL AUTO_INCREMENT,
+  `key` varbinary(1024) NOT NULL,
+  `value` longblob NOT NULL,
+  `created_at` datetime(6) NOT NULL,
+  `key_hash` bigint NOT NULL,
+  `byte_size` int NOT NULL,
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `index_solid_cache_entries_on_key_hash` (`key_hash`),
+  KEY `index_solid_cache_entries_on_byte_size` (`byte_size`),
+  KEY `index_solid_cache_entries_on_key_hash_and_byte_size` (`key_hash`,`byte_size`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
+/*!40101 SET character_set_client = @saved_cs_client */;
+/*!40103 SET TIME_ZONE=@OLD_TIME_ZONE */;
+
+/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
+/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
+/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;
+/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
+/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;
+/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;
+/*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;
+

data/lib/generators/solid_cache/install/templates/db/cache_structure.postgresql.sql

@@ -0,0 +1,128 @@
+SET statement_timeout = 0;
+SET lock_timeout = 0;
+SET idle_in_transaction_session_timeout = 0;
+SET transaction_timeout = 0;
+SET client_encoding = 'UTF8';
+SET standard_conforming_strings = on;
+SELECT pg_catalog.set_config('search_path', '', false);
+SET check_function_bodies = false;
+SET xmloption = content;
+SET client_min_messages = warning;
+SET row_security = off;
+
+SET default_tablespace = '';
+
+SET default_table_access_method = heap;
+
+--
+-- Name: ar_internal_metadata; Type: TABLE; Schema: public; Owner: -
+--
+
+CREATE TABLE public.ar_internal_metadata (
+    key character varying NOT NULL,
+    value character varying,
+    created_at timestamp(6) without time zone NOT NULL,
+    updated_at timestamp(6) without time zone NOT NULL
+);
+
+
+--
+-- Name: schema_migrations; Type: TABLE; Schema: public; Owner: -
+--
+
+CREATE TABLE public.schema_migrations (
+    version character varying NOT NULL
+);
+
+
+--
+-- Name: solid_cache_entries; Type: TABLE; Schema: public; Owner: -
+--
+
+CREATE TABLE public.solid_cache_entries (
+    id bigint NOT NULL,
+    key bytea NOT NULL,
+    value bytea NOT NULL,
+    created_at timestamp(6) without time zone NOT NULL,
+    key_hash bigint NOT NULL,
+    byte_size integer NOT NULL
+);
+
+
+--
+-- Name: solid_cache_entries_id_seq; Type: SEQUENCE; Schema: public; Owner: -
+--
+
+CREATE SEQUENCE public.solid_cache_entries_id_seq
+    START WITH 1
+    INCREMENT BY 1
+    NO MINVALUE
+    NO MAXVALUE
+    CACHE 1;
+
+
+--
+-- Name: solid_cache_entries_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: -
+--
+
+ALTER SEQUENCE public.solid_cache_entries_id_seq OWNED BY public.solid_cache_entries.id;
+
+
+--
+-- Name: solid_cache_entries id; Type: DEFAULT; Schema: public; Owner: -
+--
+
+ALTER TABLE ONLY public.solid_cache_entries ALTER COLUMN id SET DEFAULT nextval('public.solid_cache_entries_id_seq'::regclass);
+
+
+--
+-- Name: ar_internal_metadata ar_internal_metadata_pkey; Type: CONSTRAINT; Schema: public; Owner: -
+--
+
+ALTER TABLE ONLY public.ar_internal_metadata
+    ADD CONSTRAINT ar_internal_metadata_pkey PRIMARY KEY (key);
+
+
+--
+-- Name: schema_migrations schema_migrations_pkey; Type: CONSTRAINT; Schema: public; Owner: -
+--
+
+ALTER TABLE ONLY public.schema_migrations
+    ADD CONSTRAINT schema_migrations_pkey PRIMARY KEY (version);
+
+
+--
+-- Name: solid_cache_entries solid_cache_entries_pkey; Type: CONSTRAINT; Schema: public; Owner: -
+--
+
+ALTER TABLE ONLY public.solid_cache_entries
+    ADD CONSTRAINT solid_cache_entries_pkey PRIMARY KEY (id);
+
+
+--
+-- Name: index_solid_cache_entries_on_byte_size; Type: INDEX; Schema: public; Owner: -
+--
+
+CREATE INDEX index_solid_cache_entries_on_byte_size ON public.solid_cache_entries USING btree (byte_size);
+
+
+--
+-- Name: index_solid_cache_entries_on_key_hash; Type: INDEX; Schema: public; Owner: -
+--
+
+CREATE UNIQUE INDEX index_solid_cache_entries_on_key_hash ON public.solid_cache_entries USING btree (key_hash);
+
+
+--
+-- Name: index_solid_cache_entries_on_key_hash_and_byte_size; Type: INDEX; Schema: public; Owner: -
+--
+
+CREATE INDEX index_solid_cache_entries_on_key_hash_and_byte_size ON public.solid_cache_entries USING btree (key_hash, byte_size);
+
+
+--
+-- PostgreSQL database dump complete
+--
+
+SET search_path TO "$user", public;
+

data/lib/generators/solid_cache/install/templates/db/cache_structure.sqlite3.sql

@@ -0,0 +1,6 @@
+CREATE TABLE IF NOT EXISTS "schema_migrations" ("version" varchar NOT NULL PRIMARY KEY);
+CREATE TABLE IF NOT EXISTS "ar_internal_metadata" ("key" varchar NOT NULL PRIMARY KEY, "value" varchar, "created_at" datetime(6) NOT NULL, "updated_at" datetime(6) NOT NULL);
+CREATE TABLE IF NOT EXISTS "solid_cache_entries" ("id" integer PRIMARY KEY AUTOINCREMENT NOT NULL, "key" blob(1024) NOT NULL, "value" blob(536870912) NOT NULL, "created_at" datetime(6) NOT NULL, "key_hash" integer(8) NOT NULL, "byte_size" integer(4) NOT NULL);
+CREATE INDEX "index_solid_cache_entries_on_byte_size" ON "solid_cache_entries" ("byte_size");
+CREATE INDEX "index_solid_cache_entries_on_key_hash_and_byte_size" ON "solid_cache_entries" ("key_hash", "byte_size");
+CREATE UNIQUE INDEX "index_solid_cache_entries_on_key_hash" ON "solid_cache_entries" ("key_hash");

data/lib/solid_cache_mongoid/configuration.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module SolidCacheMongoid
+  class Configuration
+    attr_reader :store_options, :database, :client, :collection, :executor, :size_estimate_samples, :encrypt, :encryption_context_properties
+
+    def initialize(
+      store_options: {}, database: nil, collection: nil, client: nil,
+      executor: nil, encrypt: false, encryption_context_properties: nil, size_estimate_samples: 10_000
+    )
+      @store_options = store_options
+      @size_estimate_samples = size_estimate_samples
+      @executor = executor
+      @encrypt = encrypt
+      @client = client
+      @collection = collection || "solid_cache_entries"
+      @database = database || "solid_cache_mongoid"
+      @encryption_context_properties = encryption_context_properties
+      @encryption_context_properties ||= default_encryption_context_properties if encrypt?
+    end
+
+    def encrypt?
+      encrypt.present?
+    end
+
+    private
+      def default_encryption_context_properties
+        { deterministic: false }
+      end
+  end
+end

data/lib/solid_cache_mongoid/connections/unmanaged.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module SolidCacheMongoid
+  module Connections
+    class Unmanaged
+      def with_each
+        return enum_for(:with_each) unless block_given?
+
+        yield
+      end
+
+      def with(name)
+        yield
+      end
+
+      def with_connection_for(key)
+        yield
+      end
+
+      def assign(keys)
+        { default: keys }
+      end
+
+      def count
+        1
+      end
+
+      def names
+        [ :default ]
+      end
+    end
+  end
+end

data/lib/solid_cache_mongoid/connections.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module SolidCacheMongoid
+  module Connections
+    def self.from_config(_ = nil)
+      Unmanaged.new
+    end
+  end
+end

data/lib/solid_cache_mongoid/engine.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "mongoid"
+
+module SolidCacheMongoid
+  class Engine < ::Rails::Engine
+    isolate_namespace SolidCacheMongoid
+
+    config.solid_cache = ActiveSupport::OrderedOptions.new
+
+    initializer "solid_cache_mongoid.config", before: :initialize_cache do |app|
+      config_paths = %w[config/cache config/solid_cache_mongoid]
+
+      config_paths.each do |path|
+        app.paths.add path, with: ENV["SOLID_CACHE_CONFIG"] || "#{path}.yml"
+      end
+
+      config_pathname = config_paths.map { |path| Pathname.new(app.config.paths[path].first) }.find(&:exist?)
+
+      options = config_pathname ? app.config_for(config_pathname).to_h.deep_symbolize_keys : {}
+
+      options[:size_estimate_samples] = config.solid_cache.size_estimate_samples if config.solid_cache.size_estimate_samples
+      options[:encrypt] = config.solid_cache.encrypt if config.solid_cache.encrypt
+      options[:encryption_context_properties] = config.solid_cache.encryption_context_properties if config.solid_cache.encryption_context_properties
+
+      SolidCacheMongoid.configuration = SolidCacheMongoid::Configuration.new(**options)
+    end
+
+    initializer "solid_cache_mongoid.app_executor", before: :run_prepare_callbacks do |app|
+      SolidCacheMongoid.executor = config.solid_cache.executor || app.executor
+    end
+
+    config.after_initialize do
+      Rails.cache.setup! if Rails.cache.is_a?(Store)
+    end
+  end
+end

data/lib/solid_cache_mongoid/store/api.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module SolidCacheMongoid
+  class Store
+    module Api
+      DEFAULT_MAX_KEY_BYTESIZE = 1024
+
+      attr_reader :max_key_bytesize
+
+      def initialize(options = {})
+        super(options)
+
+        @max_key_bytesize = options.fetch(:max_key_bytesize, DEFAULT_MAX_KEY_BYTESIZE)
+      end
+
+      def increment(name, amount = 1, options = nil)
+        options = merged_options(options)
+        key = normalize_key(name, options)
+
+        instrument :increment, key, amount: amount do
+          adjust(name, amount, options)
+        end
+      end
+
+      def decrement(name, amount = 1, options = nil)
+        options = merged_options(options)
+        key = normalize_key(name, options)
+
+        instrument :decrement, key, amount: amount do
+          adjust(name, -amount, options)
+        end
+      end
+
+      def cleanup(options = nil)
+        raise NotImplementedError.new("#{self.class.name} does not support cleanup")
+      end
+
+      def clear(options = nil)
+        entry_clear
+      end
+
+      private
+        def read_entry(key, **options)
+          deserialize_entry(read_serialized_entry(key, **options), **options)
+        end
+
+        def read_serialized_entry(key, **options)
+          entry_read(key)
+        end
+
+        def write_entry(key, entry, raw: false, unless_exist: false, **options)
+          payload = serialize_entry(entry, raw: raw, **options)
+
+          if unless_exist
+            written = false
+            entry_lock_and_write(key) do |value|
+              if value.nil? || deserialize_entry(value, **options).expired?
+                written = true
+                payload
+              end
+            end
+          else
+            written = entry_write(key, payload)
+          end
+
+          write_serialized_entry(key, payload, raw: raw, returning: written, **options)
+          written
+        end
+
+        def write_serialized_entry(key, payload, raw: false, unless_exist: false, expires_in: nil, race_condition_ttl: nil, returning: true, **options)
+          returning
+        end
+
+        def read_serialized_entries(keys)
+          entry_read_multi(keys).reduce(&:merge!)
+        end
+
+        def read_multi_entries(names, **options)
+          keys_and_names = names.index_by { |name| normalize_key(name, options) }
+          serialized_entries = read_serialized_entries(keys_and_names.keys)
+
+          keys_and_names.each_with_object({}) do |(key, name), results|
+            serialized_entry = serialized_entries[key]
+            entry = deserialize_entry(serialized_entry, **options)
+
+            next unless entry
+
+            version = normalize_version(name, options)
+
+            if entry.expired?
+              delete_entry(key, **options)
+            elsif !entry.mismatched?(version)
+              if defined? ActiveSupport::Cache::DeserializationError
+                begin
+                  results[name] = entry.value
+                rescue ActiveSupport::Cache::DeserializationError
+                end
+              else
+                results[name] = entry.value
+              end
+            end
+          end
+        end
+
+        def write_multi_entries(entries, expires_in: nil, **options)
+          if entries.any?
+            serialized_entries = serialize_entries(entries, **options)
+            # to add them to the local cache
+            serialized_entries.each do |entries|
+              write_serialized_entry(entries[:key], entries[:value])
+            end
+
+            entry_write_multi(serialized_entries).all?
+          end
+        end
+
+        def delete_entry(key, **options)
+          entry_delete(key)
+        end
+
+        def delete_multi_entries(entries, **options)
+          entry_delete_multi(entries).compact.sum
+        end
+
+        def serialize_entry(entry, raw: false, **options)
+          super(entry, raw: raw, **options)
+        end
+
+        def serialize_entries(entries, **options)
+          entries.map do |key, entry|
+            { key: key, value: serialize_entry(entry, **options) }
+          end
+        end
+
+        def deserialize_entry(payload, **)
+          super(payload)
+        end
+
+        def normalize_key(key, options)
+          truncate_key super&.b
+        end
+
+        def truncate_key(key)
+          if key && key.bytesize > max_key_bytesize
+            suffix = ":hash:#{ActiveSupport::Digest.hexdigest(key)}"
+            truncate_at = max_key_bytesize - suffix.bytesize
+            "#{key.byteslice(0, truncate_at)}#{suffix}".b
+          else
+            key
+          end
+        end
+
+        def adjust(name, amount, options)
+          options = merged_options(options)
+          key = normalize_key(name, options)
+
+          new_value = entry_lock_and_write(key) do |value|
+            serialize_entry(adjusted_entry(value, amount, options))
+          end
+          deserialize_entry(new_value, **options).value if new_value
+        end
+
+        def adjusted_entry(value, amount, options)
+          entry = deserialize_entry(value, **options)
+
+          if entry && !entry.expired?
+            ActiveSupport::Cache::Entry.new \
+              amount + entry.value.to_i, **options.dup.merge(expires_in: nil, expires_at: entry.expires_at)
+          elsif /\A\d+\z/.match?(value)
+            # This is to match old raw values
+            ActiveSupport::Cache::Entry.new(amount + value.to_i, **options)
+          else
+            ActiveSupport::Cache::Entry.new(amount, **options)
+          end
+        end
+    end
+  end
+end