active-query 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4347cec583ea17647d5682b4dd2f5b16c9ae0a0c83191347621fc178803a18f6
-  data.tar.gz: 98e038e370148432ead3776deb5ed1ac5d2920d6c173a481f93e92f621415450
+  metadata.gz: 597183debb31f2b4490361200975eccbeeec9ef03e5d844abfe193e4114284d2
+  data.tar.gz: c82fd9b968a2dffcdd83914ea08bdc7b332453322008e41436d3f7ff7221e53e
 SHA512:
-  metadata.gz: 85c9eb44295160425ad65161336792360e850d75b979a0ed0f795e2c302cc72edf1aa029779136dee5d63276a1d612248c8a401bc875a172d9751b8f1f7fb99c
-  data.tar.gz: a98c8473ca1028397aa37d5240d792846563b9f3a7475d05db4a71dad4d198a218d682c3fed11dc2ddccbeed7d765188b6030def84beaef5e3c4c53a11d0aac1
+  metadata.gz: c8abf99aad689c83d93223dfa5de1e5e7c2ece56b6235ca6594b50f2b5413a03a06e8fb44dbf815137c3217e5eebf18335f52204450b3aab7899e7064a969d65
+  data.tar.gz: 8c5165ccf7c2463198e39748fcf47f5c92bc916dd5ce6f6b448e5f682c18b88fdfe05d774e385a0f716cb6bc776f822357705834878f1fe96114b2eed74bdf4e

data/.byebug_history

@@ -0,0 +1,49 @@
+c
+subject
+c
+subject
+c
+subject
+c
+subject
+c
+subject
+c
+subject
+c
+DummyModel.count
+c
+DummyModel.count
+c
+subject
+c
+ const_defined?(model_class_name)
+model_class_name
+n
+c
+DummyModel.create!(name: 'Dummy')
+c
+DummyModel.new
+DummyModel.class
+DummyModel
+c
+DummyModel.table_name
+DummyModel.class
+DummyModel
+DummyModel.create
+DummyModel.creat
+c
+model_name
+c
+model_name
+c
+@__model
+self.name
+self
+c
+self.class.name
+self.class
+self.name
+self
+c
+ActiveRecord::Base.connection

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/CHANGELOG.md

@@ -0,0 +1,35 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.0.1] - 2024-12-19
+
+### Added
+- Initial release of ActiveQuery gem
+- Query object DSL with `ActiveQuery::Base` module
+- Type validation for query arguments (String, Integer, Float, Boolean)
+- Support for optional arguments and default values
+- Custom scopes with `ActiveQuery::Scopes` module
+- Additional query operations: `gt`, `gteq`, `lt`, `lteq`, `like`, `start_like`, `end_like`
+- Resolver pattern support for complex queries
+- Conditional query building with `if` and `unless` methods
+- Automatic model inference from class names
+- ActiveRecord integration with Rails 6.1+ support
+- Comprehensive test suite with 100% code coverage
+- GitHub Actions CI/CD pipeline
+
+### Features
+- **Query Objects**: Create reusable query objects with clean DSL
+- **Type Safety**: Built-in argument validation
+- **Scopes**: Define custom scopes for queries
+- **Operations**: Extended query operations beyond standard ActiveRecord
+- **Resolvers**: Support complex query logic with resolver classes
+- **Conditional Logic**: Apply scopes conditionally with `if`/`unless`
+
+[Unreleased]: https://github.com/matiasasis/active-query/compare/v0.0.1...HEAD
+[0.0.1]: https://github.com/matiasasis/active-query/releases/tag/v0.0.1

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Matias Asis
+
+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,341 @@
+# ActiveQuery
+
+ActiveQuery is a Ruby gem that helps you create clean, reusable query objects with a simple DSL. It provides type validation, conditional logic, and seamless ActiveRecord integration.
+
+## Features
+
+- **Clean Query DSL**: Define queries with clear syntax and descriptions
+- **Type Safety**: Built-in argument type validation (String, Integer, Float, Boolean)
+- **Optional & Default Arguments**: Flexible argument handling
+- **Custom Operations**: Extended query operations like `gt`, `lt`, `like`, etc.
+- **Conditional Logic**: Apply scopes conditionally with `if` and `unless`
+- **Resolver Pattern**: Support for complex query logic in separate classes
+- **Custom Scopes**: Define reusable scopes within query objects
+- **ActiveRecord Integration**: Works seamlessly with ActiveRecord models
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'active-query'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+## Usage
+
+### Basic Query Object
+
+Create a query object by including `ActiveQuery::Base` and defining queries with the `query` method:
+
+```ruby
+class UserQuery
+  include ActiveQuery::Base
+  
+  # The model is automatically inferred from the class name (User)
+  # Or explicitly set it:
+  model_name 'User'
+  
+  # Simple query without arguments
+  query :active, 'Returns all active users', -> { scope.where(active: true) }
+  
+  # Query with arguments and type validation
+  query :by_email, 'Find users by email address',
+    { email: { type: String } },
+    -> (email:) { scope.where(email: email) }
+end
+```
+
+### Using Query Objects
+
+```ruby
+# Execute queries
+active_users = UserQuery.active
+user = UserQuery.by_email(email: 'john@example.com')
+
+# Chain with ActiveRecord methods
+recent_active_users = UserQuery.active.where('created_at > ?', 1.week.ago)
+```
+
+### Argument Types and Validation
+
+ActiveQuery supports several argument types with automatic validation:
+
+```ruby
+class ProductQuery
+  include ActiveQuery::Base
+  
+  query :filter_products, 'Filter products by various criteria',
+    {
+      name: { type: String },
+      price: { type: Float },
+      quantity: { type: Integer },
+      available: { type: ActiveQuery::Base::Boolean }
+    },
+    -> (name:, price:, quantity:, available:) {
+      scope.where(name: name)
+           .where(price: price)
+           .where(quantity: quantity)
+           .where(available: available)
+    }
+end
+
+# Usage with type validation
+ProductQuery.filter_products(
+  name: 'Widget',
+  price: 19.99,
+  quantity: 10,
+  available: true
+)
+
+# This will raise ArgumentError due to type mismatch
+ProductQuery.filter_products(name: 123, price: 'invalid', quantity: true, available: 'yes')
+```
+
+### Optional Arguments and Defaults
+
+```ruby
+class OrderQuery
+  include ActiveQuery::Base
+  
+  query :search_orders, 'Search orders with optional filters',
+    {
+      status: { type: String },
+      paid: { type: ActiveQuery::Base::Boolean, default: true },
+      customer_name: { type: String, optional: true }
+    },
+    -> (status:, paid:, customer_name:) {
+      scope.where(status: status)
+           .where(paid: paid)
+           .then { |s| customer_name ? s.where('customer_name LIKE ?', "%#{customer_name}%") : s }
+    }
+end
+
+# Usage - customer_name is optional, paid defaults to true
+OrderQuery.search_orders(status: 'pending')
+OrderQuery.search_orders(status: 'completed', customer_name: 'John')
+OrderQuery.search_orders(status: 'pending', paid: false, customer_name: 'Jane')
+```
+
+### Conditional Query Logic
+
+Use `if` and `unless` methods for conditional query building:
+
+```ruby
+class UserQuery
+  include ActiveQuery::Base
+  
+  query :search_users, 'Search users with conditional filters',
+    {
+      name: { type: String, optional: true },
+      active: { type: ActiveQuery::Base::Boolean, optional: true }
+    },
+    -> (name:, active:) {
+      scope.if(name.present?, -> { where('name LIKE ?', "%#{name}%") })
+           .if(active == true, -> { where(active: true) })
+    }
+  
+  query :filter_unless_admin, 'Filter users unless they are admin',
+    {
+      role: { type: String, optional: true }
+    },
+    -> (role:) {
+      scope.unless(role == 'admin', -> { where.not(role: 'admin') })
+    }
+end
+```
+
+### Extended Query Operations
+
+ActiveQuery provides additional query operations beyond standard ActiveRecord:
+
+```ruby
+class ProductQuery
+  include ActiveQuery::Base
+  
+  # Comparison operations
+  query :expensive_products, 'Products above price threshold', -> { scope.gt(:price, 100) }
+  query :affordable_products, 'Products within budget', -> { scope.lteq(:price, 50) }
+  
+  # Text search operations  
+  query :search_by_name, 'Search products by name pattern', -> { scope.like(:name, 'Phone') }
+  query :products_starting_with, 'Products starting with prefix', -> { scope.start_like(:name, 'iPhone') }
+  query :products_ending_with, 'Products ending with suffix', -> { scope.end_like(:name, 'Pro') }
+  
+  # Dynamic filtering
+  query :by_price_range, 'Filter by price range',
+    { min_price: { type: Float }, max_price: { type: Float } },
+    -> (min_price:, max_price:) {
+      scope.gteq(:price, min_price)
+           .lteq(:price, max_price)
+    }
+end
+```
+
+**Available operations:**
+- `gt(column, value)` - greater than
+- `gteq(column, value)` - greater than or equal  
+- `lt(column, value)` - less than
+- `lteq(column, value)` - less than or equal
+- `like(column, value)` - contains pattern (wraps with %)
+- `start_like(column, value)` - starts with pattern  
+- `end_like(column, value)` - ends with pattern
+
+### Custom Scopes
+
+Define reusable scopes within your query objects:
+
+```ruby
+class UserQuery
+  include ActiveQuery::Base
+  include ActiveQuery::Scopes
+  
+  # Define custom scopes
+  module Scopes
+    include ActiveQuery::Scopes
+    
+    scope :recent, -> { where('created_at > ?', 1.month.ago) }
+    scope :by_role, -> (role:) { where(role: role) }
+  end
+  
+  # Use scopes in queries
+  query :recent_admins, 'Find recent admin users', -> { scope.recent.by_role(role: 'admin') }
+  
+  query :count_recent, 'Count recent users', -> { scope.recent.count }
+end
+```
+
+### Resolver Pattern
+
+For complex query logic, use the resolver pattern to keep your query objects clean:
+
+```ruby
+# Define a resolver
+class UserStatsResolver < ActiveQuery::Resolver
+  def resolve(min_orders: 5)
+    scope.joins(:orders)
+         .group('users.id')
+         .having('COUNT(orders.id) >= ?', min_orders)
+         .select('users.*, COUNT(orders.id) as order_count')
+  end
+end
+
+# Use resolver in query object
+class UserQuery
+  include ActiveQuery::Base
+  
+  # Resolver without arguments
+  query :high_value_users, 'Users with many orders', 
+    resolver: UserStatsResolver
+  
+  # Resolver with arguments
+  query :users_with_orders, 'Users with minimum order count',
+    { min_orders: { type: Integer } },
+    resolver: UserStatsResolver
+end
+
+# Usage
+UserQuery.high_value_users
+UserQuery.users_with_orders(min_orders: 10)
+```
+
+### Query Introspection
+
+Query objects provide metadata about available queries:
+
+```ruby
+class UserQuery
+  include ActiveQuery::Base
+  
+  query :active, 'Find active users', -> { scope.where(active: true) }
+  query :by_name, 'Find by name', { name: { type: String } }, -> (name:) { scope.where(name: name) }
+end
+
+# Get all available queries
+UserQuery.queries
+# => [
+#   { name: :active, description: "Find active users", args_def: {} },
+#   { name: :by_name, description: "Find by name", args_def: { name: { type: String } } }
+# ]
+```
+
+### Error Handling
+
+ActiveQuery provides clear error messages for common mistakes:
+
+```ruby
+# Missing required arguments
+UserQuery.by_email
+# => ArgumentError: Params missing: [:email]
+
+# Wrong argument type
+UserQuery.by_email(email: 123)
+# => ArgumentError: :email must be of type String
+
+# Unknown arguments
+UserQuery.by_email(email: 'test@example.com', invalid_param: 'value')
+# => ArgumentError: Unknown params: [:invalid_param]
+
+# Optional and default together (validation error)
+query :invalid_query, 'This will fail',
+  { param: { type: String, optional: true, default: 'value' } },
+  -> (param:) { scope }
+# => ArgumentError: Optional and Default params can't be present together: [:param]
+```
+
+### Integration with Rails
+
+ActiveQuery works seamlessly with Rails applications:
+
+```ruby
+# app/queries/user_query.rb
+class UserQuery
+  include ActiveQuery::Base
+  
+  query :active, 'Active users', -> { scope.where(active: true) }
+  query :by_role, 'Users by role', { role: { type: String } }, -> (role:) { scope.where(role: role) }
+end
+
+# In controllers
+class UsersController < ApplicationController
+  def index
+    @users = UserQuery.active
+  end
+  
+  def admins
+    @admins = UserQuery.by_role(role: 'admin')
+  end
+end
+
+# In views or anywhere else
+<%= UserQuery.active.count %> active users
+```
+
+## Requirements
+
+- Ruby >= 2.6.0
+- ActiveRecord >= 6.1
+- ActiveSupport >= 6.1
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt.
+
+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`.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/matiasasis/active-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/matiasasis/active-query/blob/master/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 ActiveQuery project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/matiasasis/active-query/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/exe/active-query

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require "active_query"

data/lib/active-query.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'active_query'

data/lib/active_query/resolver.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ActiveQuery
+  class Resolver
+    attr_accessor :scope
+
+    def initialize(scope)
+      @scope = scope
+    end
+  end
+end

data/lib/active_query/version.rb

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

data/lib/active_query.rb

@@ -1,8 +1,193 @@
 # frozen_string_literal: true
 
-class ActiveQuery
-  VERSION = "0.1.0"
-  def self.hi
-    'Hello World!'
+require 'active_record'
+require 'active_support'
+require 'active_support/concern'
+require_relative 'active_query/version'
+require_relative 'active_query/resolver'
+require_relative 'active_record_relation_extensions'
+
+module ActiveQuery
+  module Base
+    extend ::ActiveSupport::Concern
+
+    class Boolean; end
+
+    included do
+      infer_model
+      @__queries = []
+    end
+
+    class_methods do
+      def model_name(model_name)
+        classified_model_name = model_name.classify
+        model = classified_model_name.safe_constantize
+        raise NameError, "Model #{classified_model_name} not found" unless model
+        raise ArgumentError, 'Model should be an ActiveRecord::Base' unless model.ancestors.include?(ActiveRecord::Base)
+
+        @__model = model
+      end
+
+      def model
+        @__model
+      end
+
+      def scope
+        raise ArgumentError, "Model not defined. Add model_name('Your::Model') to your QueryObject" unless @__model
+
+        @__scope ||= begin
+          relation = @__model.all.extending(Operations)
+          relation = relation.extending(scopes_module_name.constantize) if const_defined?(scopes_module_name)
+          relation
+        end
+      end
+
+      # Will list all queries available on query object.
+      def queries
+        @__queries
+      end
+
+      def query(name, description, args_def_or_lambda = nil, lambda = nil, **kwargs)
+        raise ArgumentError, 'name must be present' unless name.present?
+
+        if args_def_or_lambda.is_a?(Hash)
+          if kwargs[:resolver].present?
+            query_with_resolver(name, description, args_def_or_lambda, **kwargs)
+          else
+            query_with_arguments(name, description, args_def_or_lambda, lambda)
+          end
+        elsif args_def_or_lambda.is_a?(Proc)
+          query_without_args(name, description, args_def_or_lambda)
+        elsif args_def_or_lambda.nil? && kwargs[:resolver].present?
+          query_with_resolver_without_out_args(name, description, **kwargs)
+        else
+          raise ArgumentError, 'Invalid query definition'
+        end
+      end
+
+      private
+
+      def scopes_module_name
+        "#{self}::Scopes"
+      end
+
+      def infer_model
+        model_class_name = self.name.sub(/::Query$/, '').classify
+        return unless const_defined?(model_class_name)
+
+        model = model_class_name.safe_constantize
+        return unless model.ancestors.include?(ActiveRecord::Base)
+
+        model_name(model_class_name)
+      end
+
+      def query_with_arguments(name, description, args_def, lambda)
+        register_query(name, description, args_def)
+
+        define_singleton_method(name) do |given_args|
+          given_args = validate_args(name, given_args, args_def)
+          lambda.call(**given_args)
+        end
+      end
+
+      def query_without_args(name, description, lambda)
+        register_query(name, description)
+        define_singleton_method(name) { lambda.call }
+      end
+
+      def query_with_resolver(name, description, args_def, **kwargs)
+        register_query(name, description, args_def)
+        resolver = kwargs[:resolver]
+        raise 'Invalid Resolver, must inherit from ActiveQuery::Resolvers::Base' unless resolver.ancestors.include?(ActiveQuery::Resolver)
+
+        define_singleton_method(name) do |given_args|
+          given_args = validate_args(name, given_args, args_def)
+          resolver.new(scope).resolve(**given_args)
+        end
+      end
+
+      def query_with_resolver_without_out_args(name, description, **kwargs)
+        register_query(name, description)
+        resolver = kwargs[:resolver]
+        raise 'Invalid Resolver, must inherit from ActiveQuery::Resolvers::Base' unless resolver.ancestors.include?(ActiveQuery::Resolver)
+
+        define_singleton_method(name) { resolver.new(scope).resolve }
+      end
+
+      def register_query(name, description, args_def = {})
+        # Validate optional and default are not present together
+        optional_and_default = args_def.select { |key, value| value[:optional] == true && value[:default].present? }
+        raise ArgumentError, "Optional and Default params can't be present together: #{optional_and_default.keys}" if optional_and_default.present?
+
+        # Will add all queries for further serving the method 'queries'
+        @__queries << { name:, description:, args_def: }.compact_blank
+      end
+
+      def validate_args(name, given_args, args_def)
+        # Validate if the given arguments are correct
+        raise ArgumentError, "Incorrect Params, must be called '.#{name}(#{args_def.keys.map { |p| "#{p}: value" }.join(', ')})' " unless given_args.is_a?(Hash)
+
+        non_optional_args = args_def.reject { |key, value| value[:optional] == true }
+        args_not_provided = non_optional_args.keys - given_args.keys
+
+        args_with_default_to_add = args_def.select { |key, value| value[:default].present? && args_not_provided.include?(key) }
+        given_args.merge!(args_with_default_to_add.map { |key, value| [key, value[:default]] }.to_h)
+
+        missing_args = non_optional_args.keys - given_args.keys
+        raise ArgumentError, "Params missing: #{missing_args}" unless missing_args.empty?
+
+        extra_params = given_args.keys - args_def.keys
+        raise ArgumentError, "Unknown params: #{extra_params}" unless extra_params.empty?
+
+        given_args.each do |given_arg|
+          given_arg_config = args_def[given_arg.first]
+          given_arg_type = given_arg_config[:type]
+          given_arg_name = given_arg.first
+          given_arg_value = given_arg.second
+
+          if given_arg_type == ActiveQuery::Base::Boolean
+            unless given_arg_value == true || given_arg_value == false
+              raise ArgumentError, ":#{given_arg_name} must be of type Boolean"
+            end
+          else
+            unless given_arg_value.instance_of?(given_arg_type)
+              raise ArgumentError, ":#{given_arg_name} must be of type #{given_arg_type}"
+            end
+          end
+        end
+
+        # Populates all the non optional non given arguments with nil.
+        not_given_args = args_def.keys - given_args.keys
+        given_args.merge(not_given_args.map { |key| [key, nil] }.to_h)
+      end
+    end
+
+    module Operations
+      def gt(col, val) = __operation(:gt, col, val)
+      def gteq(col, val) = __operation(:gteq, col, val)
+      def lt(col, val) = __operation(:lt, col, val)
+      def lteq(col, val) = __operation(:lteq, col, val)
+      def like(col, val) = __operation(:matches, col, "%#{val}%")
+      def start_like(col, val) = __operation(:matches, col, "#{val}%")
+      def end_like(col, val) = __operation(:matches, col, "%#{val}")
+      def __operation(op, col, val) = where(arel_table[col].send(op, val))
+    end
+  end
+
+  module Scopes
+    extend ActiveSupport::Concern
+
+    included do
+      @__scopes = []
+    end
+
+    class_methods do
+      attr_accessor :__scopes
+
+      def scope(name, lambda)
+        __scopes << [name, lambda]
+        define_method(name, &lambda)
+      end
+    end
   end
 end

data/lib/active_record_relation_extensions.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ActiveRecordRelationExtensions
+  extend ActiveSupport::Concern
+
+  # Adds the `if` method to ActiveRecord::Relation
+  module ClassMethods
+    # `if` applies the given scope only if the condition is true.
+    #
+    # @param if_condition [Boolean] whether to apply the scope
+    # @param scope [Proc] a callable object representing the scope
+    # @return [ActiveRecord::Relation] the modified or original relation
+    def if(if_condition, scope)
+      return self unless if_condition
+
+      raise "Invalid Scope. Must provide a lambda '-> { your_scope(arg) }'" unless scope.is_a?(Proc)
+
+      merge(scope)
+    end
+
+    # `if` applies the given scope only if the condition is true.
+    #
+    # @param if_condition [Boolean] whether to apply the scope
+    # @param scope [Proc] a callable object representing the scope
+    # @return [ActiveRecord::Relation] the modified or original relation
+    def unless(unless_condition, scope)
+      return self if unless_condition
+
+      raise "Invalid Scope. Must provide a lambda '-> { your_scope(arg) }'" unless scope.is_a?(Proc)
+
+      merge(scope)
+    end
+  end
+end
+
+ActiveRecord::Relation.include(ActiveRecordRelationExtensions::ClassMethods)

metadata

@@ -1,27 +1,170 @@
 --- !ruby/object:Gem::Specification
 name: active-query
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Matias Asis
 autorequire:
-bindir: bin
+bindir: exe
 cert_chain: []
-date: 2024-11-28 00:00:00.000000000 Z
-dependencies: []
-description:
+date: 2025-08-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.9.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.9.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.17.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.17.1
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.5.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.5.1
+- !ruby/object:Gem::Dependency
+  name: database_cleaner-active_record
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.0'
+description: ActiveQuery is a gem that helps you to create query objects in a simple
+  way. It provides a DSL to define queries and scopes for your query object.
 email:
 - matiasis.90@gmail.com
-executables: []
+executables:
+- active-query
 extensions: []
 extra_rdoc_files: []
 files:
+- ".byebug_history"
+- ".rspec"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- exe/active-query
+- lib/active-query.rb
 - lib/active_query.rb
+- lib/active_query/resolver.rb
+- lib/active_query/version.rb
+- lib/active_record_relation_extensions.rb
 homepage: https://github.com/matiasasis/active-query
 licenses:
 - MIT
-metadata: {}
+metadata:
+  homepage_uri: https://github.com/matiasasis/active-query
+  source_code_uri: https://github.com/matiasasis/active-query
+  bug_tracker_uri: https://github.com/matiasasis/active-query/issues
+  changelog_uri: https://github.com/matiasasis/active-query/blob/master/CHANGELOG.md
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -37,8 +180,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.23
+rubygems_version: 3.4.15
 signing_key:
 specification_version: 4
-summary: This is active-query
+summary: ActiveQuery is a gem that helps you to create query objects in a simple way.
 test_files: []