rails_query 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: daae5d37d67d79fc88c2998323b2510c2e95b95492f593ddade503840b32959e
+  data.tar.gz: 144a41267c8a5694b667d92121f7282376a6e0185abadfa263cc20cd7b944aef
+SHA512:
+  metadata.gz: 90d663027ae3c7d84992bb2b75a45296b89a7f62373c2f33df91200320e33db77c4ac2efbff4a4bac831c5c34ba6c5d17e15ecf0102fa6bc6214ee6c32bb5f94
+  data.tar.gz: 7977909232374487763e24486a183cf008faa2f9f129899aa12b98d6492269e5ba0e9b702fddc8a790a39e5fce40ae61522c20a61015ca19226157f6f5890e19

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2026-04-29
+
+🚀 [FEATURE] Initial release of Rails Query

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,10 @@
+# Code of Conduct
+
+"rails_query" follows [The Ruby Community Conduct Guideline](https://www.ruby-lang.org/en/conduct) in all "collaborative space", which is defined as community communications channels (such as mailing lists, submitted patches, commit comments, etc.):
+
+* Participants will be tolerant of opposing views.
+* Participants must ensure that their language and actions are free of personal attacks and disparaging personal remarks.
+* When interpreting the words and actions of others, participants should always assume good intentions.
+* Behaviour which can be reasonably considered harassment will not be tolerated.
+
+If you have any concerns about behaviour within this project, please contact us at ["ilson.lasmar@gmail.com"](mailto:"ilson.lasmar@gmail.com").

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Ilson Lasmar (ilson.lasmar@gmail.com)
+
+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,186 @@
+# RailsQuery
+
+[![Gem Version](https://badge.fury.io/rb/rails_query.svg)](http://badge.fury.io/rb/rails_query)
+[![Build Status](https://github.com/ilsonlasmar/rails_query/actions/workflows/main.yml/badge.svg)](https://github.com/ilsonlasmar/rails_query/actions/workflows/main.yml)
+
+
+A lightweight data-fetching and mutation layer for Ruby on Rails.
+
+
+RailsQuery introduces a clear pattern for handling external APIs using:
+
+- Providers  (configuration + context) - **how to connect**
+- Queries (read + cache) - **how to read**
+- Mutations (write + invalidate) - **how to write**
+
+
+## Why RailsQuery?
+
+In most Rails projects, external API calls end up:
+
+- scattered across services, models, and controllers
+- duplicated HTTP setup (Faraday, headers, auth)
+- hard to track and debug
+- inconsistent caching strategies
+- tightly coupled and difficult to test
+
+RailsQuery solves this by centralizing and standardizing all external interactions.
+
+  architecture:
+
+```
+app/providers/
+  user_provider.rb
+  user/
+    queries/
+      find_user_query.rb
+    mutations/
+      create_user_mutation.rb
+```
+
+---
+
+## Index
+- [Installation](#installation)
+- [Usage](#usage)
+  - [Provider](#provider)
+  - [Query](#query)
+  - [Mutation](#mutation)
+- [Generators](#generators)
+- [Caching](#caching)
+- [Invalidation](#invalidation)
+
+
+## Installation
+
+Add the gem to your project
+
+```ruby
+gem "rails_query"
+```
+Then
+```bash
+bundle install
+```
+
+## Usage
+
+### Install setup
+```bash
+rails g rails_query:install
+```
+
+### Provider
+Providers define configuration and and context (HTTP client, base URL, auth)
+
+```ruby
+class UserProvider
+  include RailsQuery::Adapter
+
+  base_url ENV["USER_API_URL"]
+
+  client do
+    Faraday.new(url: base_url) do |f|
+      f.request :json
+      f.response :json
+    end
+  end
+
+  query :find_user
+  mutation :create_user
+end
+```
+
+### Query
+Queries are responsible for reading data and caching results.
+
+```ruby
+class User::Queries::FindUserQuery < RailsQuery::Query
+  ttl 5.minutes
+
+  key do |id|
+    ["users", id]
+  end
+
+  def resolve(id, opts = {})
+    client = opts.fetch(:client)
+    client.get("/users/#{id}").body
+  end
+end
+```
+Basic usage:
+```ruby
+UserProvider.find_user(1)
+```
+
+### Mutation
+Mutations are responsible for writing data and invalidating cache.
+
+```ruby
+class User::Mutations::CreateUserMutation < RailsQuery::Mutation
+  invalidates "UserProvider"
+
+  def resolve(params, opts = {})
+    client = opts.fetch(:client)
+    client.post("/users", params).body
+  end
+end
+```
+
+## Generators
+Generate queries:
+
+```bash
+rails g rails_query:query User list_users
+```
+
+Generate mutations:
+
+```bash
+rails g rails_query:mutation User update_user
+```
+
+## Caching
+Queries are cached automatically based on:
+
+- class name
+- arguments
+- keyword arguments (kwargs)
+
+```ruby
+UserProvider.find_user(1)
+UserProvider.find_user(1) # cached
+```
+
+You can configure TTL:
+
+```ruby
+ttl 5.minutes
+```
+
+## Invalidation
+
+Mutations invalidate cache after execution.
+
+```ruby
+invalidates "UserProvider"
+```
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and 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/ilsonlasmar/rails_query. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/ilsonlasmar/rails_query/blob/main/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the RailsQuery project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/ilsonlasmar/rails_query/blob/main/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module RailsQuery
+  module Generators
+    # Generator that installs RailsQuery with a provider and example query.
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Install RailsQuery with provider + example query"
+
+      def create_initializer
+        if File.exist?("config/initializers/rails_query.rb")
+          say_status("skipped", "Initializer already exists", :yellow)
+        else
+          @query_namespace = app_name.underscore
+          template "rails_query.rb.tt", "config/initializers/rails_query.rb"
+        end
+      end
+
+      def create_directories
+        empty_directory "app/providers"
+        empty_directory "app/providers/user"
+        empty_directory "app/providers/user/queries"
+      end
+
+      def create_provider
+        template "user_provider.rb.tt", "app/providers/user_provider.rb"
+      end
+
+      def create_example_query
+        template(
+          "find_user_query.rb.tt",
+          "app/providers/user/queries/find_user_query.rb"
+        )
+      end
+
+      def add_autoload_path
+        inject_into_file "config/application.rb",
+                         after: "class Application < Rails::Application\n" do
+          "    config.autoload_paths << Rails.root.join('app/providers')\n"
+        end
+      end
+
+      def show_readme
+        say "\nRailsQuery installed successfully!", :green
+      end
+
+      private
+
+      def app_name
+        Rails.application.class.module_parent_name
+      end
+    end
+  end
+end

data/lib/generators/rails_query/install/templates/find_user_query.rb.tt

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# Fake query to simulate fetching user data.
+class User::Queries::FindUserQuery < RailsQuery::Query
+  ttl 30.seconds
+
+  key do |id|
+    [ "user", id ]
+  end
+
+  def resolve(id)
+    {
+      id: id,
+      name: "User #{id}",
+      fetched_at: Time.current
+    }
+  end
+end

data/lib/generators/rails_query/install/templates/rails_query.rb.tt

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+RailsQuery.configure do |config|
+  config.default_ttl = 30.seconds
+  config.namespace = "<%= @query_namespace %>"
+
+  # Example with Redis:
+  # config.cache_store = ActiveSupport::Cache::RedisCacheStore.new(
+  #   url: ENV["REDIS_URL"]
+  # )
+end

data/lib/generators/rails_query/install/templates/user_provider.rb.tt

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class UserProvider
+  include RailsQuery::Adapter
+
+  # User::Queries::FindUserQuery
+  query :find_user
+end

data/lib/generators/rails_query/mutation/mutation_generator.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module RailsQuery
+  module Generators
+    # Generator that creates a provider and mutations based on the provided name and mutation list.
+    class MutationGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path("templates", __dir__)
+
+      argument :mutations, type: :array, default: []
+
+      def create_provider_directory
+        empty_directory "app/providers"
+      end
+
+      def create_mutations_directory
+        empty_directory "app/providers/#{file_name}/mutations"
+      end
+
+      def create_provider_file
+        @provider_module = class_name
+        template "provider.rb.tt", "app/providers/#{file_name}_provider.rb"
+      end
+
+      def create_mutation_files
+        mutations.each do |mutation|
+          @mutation_name = mutation
+          @provider_module = class_name
+
+          template(
+            "mutation.rb.tt",
+            "app/providers/#{file_name}/mutations/#{mutation}_mutation.rb"
+          )
+        end
+      end
+
+      def add_mutations_to_provider
+        provider_path = "app/providers/#{file_name}_provider.rb"
+        return unless File.exist?(provider_path)
+
+        content = File.read(provider_path)
+
+        pending_mutations = mutations.reject do |mutation|
+          content.match?(/^\s*mutation\s+:#{Regexp.escape(mutation)}\b/)
+        end
+
+        return if pending_mutations.empty?
+
+        inject_into_file provider_path, after: "include RailsQuery::Adapter\n" do
+          pending_mutations.map { |mutation| "\n  mutation :#{mutation}\n" }.join
+        end
+      end
+
+      def show_usage
+        say "\nMutations created successfully!", :green
+      end
+    end
+  end
+end

data/lib/generators/rails_query/mutation/templates/mutation.rb.tt

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class <%= @provider_module %>::Mutations::<%= @mutation_name.camelize %>Mutation < RailsQuery::Mutation
+  invalidates "<%= @provider_module %>Provider"
+
+  def resolve(*args, **opts)
+    # TODO: implement the actual API call to mutate
+
+    # client = opts.fetch(:client)
+    # response = client.post("/users")
+    # response.body
+  end
+end

data/lib/generators/rails_query/mutation/templates/provider.rb.tt

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class <%= @provider_module.camelize %>Provider
+  include RailsQuery::Adapter
+end

data/lib/generators/rails_query/query/query_generator.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module RailsQuery
+  module Generators
+    # Generator that creates a provider and queries based on the provided name and query list.
+    class QueryGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path("templates", __dir__)
+
+      argument :queries, type: :array, default: []
+
+      def create_provider_directory
+        empty_directory "app/providers"
+      end
+
+      def create_queries_directory
+        empty_directory "app/providers/#{file_name}/queries"
+      end
+
+      def create_provider_file
+        @provider_module = class_name
+        template "provider.rb.tt", "app/providers/#{file_name}_provider.rb"
+      end
+
+      def create_query_files
+        queries.each do |query|
+          @query_name = query
+          @provider_module = class_name
+
+          template(
+            "query.rb.tt",
+            "app/providers/#{file_name}/queries/#{query}_query.rb"
+          )
+        end
+      end
+
+      def add_queries_to_provider
+        provider_path = "app/providers/#{file_name}_provider.rb"
+        return unless File.exist?(provider_path)
+
+        content = File.read(provider_path)
+
+        pending_queries = queries.reject do |query|
+          content.match?(/^\s*query\s+:#{Regexp.escape(query)}\b/)
+        end
+
+        return if pending_queries.empty?
+
+        inject_into_file provider_path, after: "include RailsQuery::Adapter\n" do
+          pending_queries.map { |query| "\n  query :#{query}\n" }.join
+        end
+      end
+
+      def show_usage
+        say "\nQueries created successfully!", :green
+      end
+    end
+  end
+end

data/lib/generators/rails_query/query/templates/provider.rb.tt

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class <%= @provider_module.camelize %>Provider
+  include RailsQuery::Adapter
+end

data/lib/generators/rails_query/query/templates/query.rb.tt

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class <%= @provider_module %>::Queries::<%= @query_name.camelize %>Query < RailsQuery::Query
+  ttl 30.seconds
+
+  # TODO: implement cache key strategy
+  # key do |id|
+  #   [ "<%= file_name %>", id ]
+  # end
+
+  def resolve(*args, **opts)
+    # TODO: implement the actual API call to fetch
+
+    # client = opts.fetch(:client)
+    # response = client.get("/users/#{args.first}")
+    # response.body
+  end
+end

data/lib/rails_query/adapter.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module RailsQuery
+  # Adapter module to be included in provider classes for defining queries and mutations
+  module Adapter
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # Class methods for defining base URL, client, queries, and mutations
+    module ClassMethods
+      def base_url(url = nil)
+        return @base_url if url.nil?
+
+        @base_url = url
+      end
+
+      def client(&block)
+        return @client_block if block.nil?
+
+        @client_block = block
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def query(name, ttl: nil, &block)
+        define_method(name) do |*args, **opts|
+          opts_with_context = inject_context(**opts)
+
+          if block
+            execute_with_cache(name, ttl, args) do
+              instance_exec(*args, **opts_with_context, &block)
+            end
+          else
+            query_class = resolve_query_class(name)
+            query_class.call(*args, **opts_with_context)
+          end
+        end
+
+        define_singleton_method(name) do |*args, **opts|
+          instance.public_send(name, *args, **opts)
+        end
+      end
+
+      def mutation(name, &block)
+        define_method(name) do |*args, **opts|
+          opts_with_context = inject_context(**opts)
+
+          if block
+            instance_exec(*args, **opts_with_context, &block)
+          else
+            mutation_class = resolve_mutation_class(name)
+            mutation_class.call(*args, **opts_with_context)
+          end
+        end
+
+        define_singleton_method(name) do |*args, **opts|
+          instance.public_send(name, *args, **opts)
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      private
+
+      def instance
+        RailsQuery::Adapter.instance_for(self)
+      end
+    end
+
+    def self.instance_for(klass)
+      @instances ||= {}
+      @instances[klass] ||= klass.new
+    end
+
+    def base_url
+      self.class.base_url
+    end
+
+    def client
+      @client ||= instance_exec(&self.class.client) if self.class.client
+    end
+
+    private
+
+    def execute_with_cache(name, ttl, args, &block)
+      return yield unless ttl
+
+      key = RailsQuery::KeyBuilder.build([self.class.name, name, args])
+
+      RailsQuery.client.fetch(key, ttl: ttl, provider: self.class.name, &block)
+    end
+
+    def inject_context(**opts)
+      {
+        client: (respond_to?(:client) ? client : nil),
+        base_url: (respond_to?(:base_url) ? base_url : nil),
+        provider: self.class.name
+      }.merge(opts)
+    end
+
+    def resolve_query_class(name)
+      provider = self.class.name.sub("Provider", "")
+      class_name = "#{name.to_s.camelize}Query"
+
+      "#{provider}::Queries::#{class_name}".constantize
+    end
+
+    def resolve_mutation_class(name)
+      provider = self.class.name.sub("Provider", "")
+      class_name = "#{name.to_s.camelize}Mutation"
+
+      "#{provider}::Mutations::#{class_name}".constantize
+    end
+  end
+end

data/lib/rails_query/client.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RailsQuery
+  # Internal client class responsible for cache interactions
+  class Client
+    def initialize(config)
+      @cache       = config.cache_store
+      @default_ttl = config.default_ttl
+      @namespace   = config.namespace
+      @logger      = config.logger
+    end
+
+    def fetch(key, ttl: @default_ttl, provider: nil, &block)
+      store_index(provider, key) if provider
+      namespaced = namespaced_key(key)
+      @cache.fetch(namespaced, expires_in: ttl, &block)
+    end
+
+    def store_index(provider, key)
+      return unless provider
+
+      idx_key = index_key(provider)
+
+      keys = @cache.read(idx_key) || []
+      keys << key
+
+      @cache.write(idx_key, keys.uniq)
+    end
+
+    def invalidate_provider(provider)
+      index_key = index_key(provider)
+
+      keys = @cache.read(index_key) || []
+
+      keys.each do |digest|
+        @cache.delete(namespaced_key(digest))
+      end
+
+      @cache.delete(index_key)
+    end
+
+    def invalidate(key)
+      @cache.delete(namespaced_key(key))
+    end
+
+    private
+
+    def namespaced_key(key)
+      "#{@namespace}:#{Array(key).join(":")}"
+    end
+
+    def index_key(provider)
+      "#{@namespace}:index:#{provider.to_s.underscore}"
+    end
+  end
+end

data/lib/rails_query/configuration.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RailsQuery
+  # Configuration class for RailsQuery
+  class Configuration
+    attr_accessor :cache_store, :default_ttl, :namespace, :logger
+
+    def initialize
+      @cache_store = default_cache_store
+      @default_ttl = 30.seconds
+      @namespace = "rails_query"
+      @logger = default_logger
+    end
+
+    private
+
+    def default_cache_store
+      if defined?(Rails) && Rails.respond_to?(:cache)
+        Rails.cache
+      else
+        ActiveSupport::Cache::MemoryStore.new
+      end
+    end
+
+    def default_logger
+      if defined?(Rails) && Rails.respond_to?(:logger)
+        Rails.logger
+      else
+        Logger.new($stdout)
+      end
+    end
+  end
+end

data/lib/rails_query/mutation.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RailsQuery
+  # Base class for mutations
+  class Mutation
+    class << self
+      def call(*args, **opts)
+        new.call(*args, **opts)
+      end
+
+      def invalidates(*providers)
+        @invalidates = providers
+      end
+
+      def invalidation_targets
+        @invalidates || []
+      end
+    end
+
+    def call(*args, **opts)
+      result = kwargs? ? resolve(*args, **opts) : resolve(*args)
+      invalidate!
+
+      result
+    end
+
+    def kwargs?
+      method(:resolve).parameters.any? { |type, _| %i[keyrest opt].include?(type) }
+    end
+
+    def resolve(*)
+      raise NotImplementedError
+    end
+
+    private
+
+    def invalidate!
+      self.class.invalidation_targets.each do |provider|
+        RailsQuery.invalidate_provider(provider)
+      end
+    end
+  end
+end

data/lib/rails_query/query.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RailsQuery
+  # Base class for queries
+  class Query
+    class << self
+      def call(*args, **opts)
+        new.call(*args, **opts)
+      end
+
+      def ttl(value = nil)
+        @ttl = value if value
+        @ttl
+      end
+
+      def key(&block)
+        @key_block = block if block
+        @key_block
+      end
+    end
+
+    def call(*args, **opts)
+      key = build_key(*args, **opts)
+      provider_class = opts[:provider] || self.class.name
+      RailsQuery.client.fetch(key, ttl: ttl, provider: provider_class) do
+        kwargs? ? resolve(*args, **opts) : resolve(*args)
+      end
+    end
+
+    def ttl
+      self.class.ttl || RailsQuery.configuration.default_ttl
+    end
+
+    def build_key(*args, **opts)
+      opts = opts.select { |k, _| self.class.key.parameters.map(&:last).include?(k) }
+      return instance_exec(*args, **opts, &self.class.key) if self.class.key
+
+      [self.class.name, args]
+    end
+
+    def kwargs?
+      method(:resolve).parameters.any? { |type, _| %i[keyrest opt].include?(type) }
+    end
+
+    def resolve(*)
+      raise NotImplementedError
+    end
+  end
+end

data/lib/rails_query/railtie.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module RailsQuery
+  # Railtie to integrate with Rails applications
+  class Railtie < Rails::Railtie
+    initializer "rails_query.setup" do
+      RailsQuery.configure do |config|
+        config.cache_store = Rails.cache if defined?(Rails.cache)
+      end
+    end
+  end
+end

data/lib/rails_query/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RailsQuery
+  VERSION = "0.1.0"
+end

data/lib/rails_query.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_support/cache"
+require "active_support/core_ext/numeric/time"
+
+require_relative "rails_query/version"
+require_relative "rails_query/configuration"
+require_relative "rails_query/client"
+require_relative "rails_query/query"
+require_relative "rails_query/mutation"
+require_relative "rails_query/adapter"
+
+# Main module for RailsQuery
+module RailsQuery
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration) if block_given?
+    end
+
+    def reset_configuration!
+      @_configuration = nil
+    end
+
+    def client
+      @client ||= Client.new(configuration)
+    end
+
+    def invalidate_provider(provider)
+      client.invalidate_provider(provider)
+    end
+  end
+end
+
+require_relative "rails_query/railtie" if defined?(Rails)

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: rails_query
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ilson Lasmar
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.14'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+description: |
+  RailsQuery provides a declarative abstraction for fetching, caching, and
+  managing remote or expensive data in Rails applications.
+
+  Inspired by modern data-fetching patterns, it introduces query lifecycle
+  concepts such as caching, stale-while-revalidate, automatic invalidation,
+  and request deduplication, while remaining idiomatic to the Rails ecosystem.
+email:
+- ilson.lasmar@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/generators/rails_query/install/install_generator.rb
+- lib/generators/rails_query/install/templates/find_user_query.rb.tt
+- lib/generators/rails_query/install/templates/rails_query.rb.tt
+- lib/generators/rails_query/install/templates/user_provider.rb.tt
+- lib/generators/rails_query/mutation/mutation_generator.rb
+- lib/generators/rails_query/mutation/templates/mutation.rb.tt
+- lib/generators/rails_query/mutation/templates/provider.rb.tt
+- lib/generators/rails_query/query/query_generator.rb
+- lib/generators/rails_query/query/templates/provider.rb.tt
+- lib/generators/rails_query/query/templates/query.rb.tt
+- lib/rails_query.rb
+- lib/rails_query/adapter.rb
+- lib/rails_query/client.rb
+- lib/rails_query/configuration.rb
+- lib/rails_query/mutation.rb
+- lib/rails_query/query.rb
+- lib/rails_query/railtie.rb
+- lib/rails_query/version.rb
+homepage: https://github.com/ilsonlasmar/rails_query
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/ilsonlasmar/rails_query
+  source_code_uri: https://github.com/ilsonlasmar/rails_query
+  changelog_uri: https://github.com/ilsonlasmar/rails_query/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: Declarative query caching layer with lifecycle management for Rails
+test_files: []