quo 0.6.0 → 1.0.0.beta1

data/sig/generated/quo/composed_query.rbs

@@ -0,0 +1,112 @@
+# Generated from lib/quo/composed_query.rb with RBS::Inline
+
+module Quo
+  module ComposedQuery
+    # Combine two Query classes into a new composed query class
+    # Combine two query-like or composeable entities:
+    # These can be Quo::Query, Quo::ComposedQuery, Quo::CollectionBackedQuery and ActiveRecord::Relations.
+    # See the `README.md` docs for more details.
+    # @rbs chosen_superclass: singleton(Quo::RelationBackedQuery | Quo::CollectionBackedQuery)
+    # @rbs left_query_class: singleton(Quo::Query | ::ActiveRecord::Relation)
+    # @rbs right_query_class: singleton(Quo::Query | ::ActiveRecord::Relation)
+    # @rbs joins: untyped
+    # @rbs return: singleton(Quo::ComposedQuery)
+    def self?.composer: (untyped chosen_superclass, untyped left_query_class, untyped right_query_class, ?joins: untyped) -> singleton(Quo::ComposedQuery)
+
+    # We can also merge instance of prepared queries
+    # @rbs left_instance: Quo::Query | ::ActiveRecord::Relation
+    # @rbs right_instance: Quo::Query | ::ActiveRecord::Relation
+    # @rbs joins: untyped
+    # @rbs return: Quo::ComposedQuery
+    def self?.merge_instances: (Quo::Query | ::ActiveRecord::Relation left_instance, Quo::Query | ::ActiveRecord::Relation right_instance, ?joins: untyped) -> Quo::ComposedQuery
+
+    # @rbs override
+    def query: ...
+
+    # @rbs override
+    def inspect: ...
+
+    # @rbs left_query_class: singleton(Quo::Query | ::ActiveRecord::Relation)
+    # @rbs right_query_class: singleton(Quo::Query | ::ActiveRecord::Relation)
+    private def self.validate_query_classes: (untyped left_query_class, untyped right_query_class) -> untyped
+
+    # @rbs left_query_class: singleton(Quo::Query | ::ActiveRecord::Relation)
+    # @rbs right_query_class: singleton(Quo::Query | ::ActiveRecord::Relation)
+    private def self.collect_properties: (untyped left_query_class, untyped right_query_class) -> untyped
+
+    private def self.create_composed_class: (untyped chosen_superclass, untyped props) -> untyped
+
+    # @rbs klass: Class
+    # @rbs left_query_class: singleton(Quo::Query | ::ActiveRecord::Relation)
+    # @rbs right_query_class: singleton(Quo::Query | ::ActiveRecord::Relation)
+    # @rbs joins: untyped
+    private def self.assign_query_metadata: (Class klass, untyped left_query_class, untyped right_query_class, untyped joins) -> untyped
+
+    # @rbs left_instance: Quo::Query | ::ActiveRecord::Relation
+    # @rbs right_instance: Quo::Query | ::ActiveRecord::Relation
+    private def self.validate_instances: (Quo::Query | ::ActiveRecord::Relation left_instance, Quo::Query | ::ActiveRecord::Relation right_instance) -> untyped
+
+    # @rbs relation: ::ActiveRecord::Relation
+    # @rbs query: Quo::Query
+    # @rbs joins: untyped
+    private def self.merge_query_and_relation: (Quo::Query query, ::ActiveRecord::Relation relation, untyped joins) -> untyped
+
+    # @rbs relation: ::ActiveRecord::Relation
+    # @rbs query: Quo::Query
+    # @rbs joins: untyped
+    private def self.merge_relation_and_query: (::ActiveRecord::Relation relation, Quo::Query query, untyped joins) -> untyped
+
+    # @rbs left_query: Quo::Query | ::ActiveRecord::Relation
+    # @rbs right_query: Quo::Query | ::ActiveRecord::Relation
+    private def self.merge_query_instances: (Quo::Query | ::ActiveRecord::Relation left_query, Quo::Query | ::ActiveRecord::Relation right_query, untyped joins) -> untyped
+
+    # @rbs left_query: Quo::Query | ::ActiveRecord::Relation
+    # @rbs right_query: Quo::Query | ::ActiveRecord::Relation
+    private def self.determine_base_class_for_queries: (Quo::Query | ::ActiveRecord::Relation left_query, Quo::Query | ::ActiveRecord::Relation right_query) -> untyped
+
+    private
+
+    # @rbs return: Hash[Symbol, untyped]
+    def child_options: (untyped query_class) -> Hash[Symbol, untyped]
+
+    # @rbs return: Array[Symbol]
+    def property_names: (untyped query_class) -> Array[Symbol]
+
+    # @rbs return: Quo::Query | ::ActiveRecord::Relation
+    def left: () -> (Quo::Query | ::ActiveRecord::Relation)
+
+    # @rbs return: Quo::Query | ::ActiveRecord::Relation
+    def right: () -> (Quo::Query | ::ActiveRecord::Relation)
+
+    # @rbs return: ActiveRecord::Relation | CollectionBackedQuery
+    def merge_left_and_right: () -> (ActiveRecord::Relation | CollectionBackedQuery)
+
+    # @rbs left_rel: ActiveRecord::Relation
+    # @rbs right_rel: ActiveRecord::Relation
+    # @rbs return: ActiveRecord::Relation
+    def merge_active_record_relations: (ActiveRecord::Relation left_rel, ActiveRecord::Relation right_rel) -> ActiveRecord::Relation
+
+    # @rbs left_rel: ActiveRecord::Relation
+    # @rbs return: ActiveRecord::Relation
+    def apply_joins: (ActiveRecord::Relation left_rel) -> ActiveRecord::Relation
+
+    # @rbs rel: untyped
+    # @rbs return: bool
+    def is_relation?: (untyped rel) -> bool
+
+    # @rbs left: untyped
+    # @rbs right: untyped
+    # @rbs return: bool
+    def both_relations?: (untyped left, untyped right) -> bool
+
+    # @rbs left: untyped
+    # @rbs right: untyped
+    # @rbs return: bool
+    def left_relation_right_enumerable?: (untyped left, untyped right) -> bool
+
+    # @rbs left: untyped
+    # @rbs right: untyped
+    # @rbs return: bool
+    def left_enumerable_right_relation?: (untyped left, untyped right) -> bool
+  end
+end

data/sig/generated/quo/engine.rbs

@@ -0,0 +1,6 @@
+# Generated from lib/quo/engine.rb with RBS::Inline
+
+module Quo
+  class Engine < ::Rails::Engine
+  end
+end

data/sig/generated/quo/preloadable.rbs

@@ -0,0 +1,29 @@
+# Generated from lib/quo/preloadable.rb with RBS::Inline
+
+module Quo
+  module Preloadable
+    def self.included: (untyped base) -> untyped
+
+    # This implementation of `query` calls `collection` and preloads the includes.
+    # @rbs return: Object & Enumerable[untyped]
+    def query: () -> (Object & Enumerable[untyped])
+
+    # For use with collections of ActiveRecord models.
+    # Configures ActiveRecord::Associations::Preloader to load associations of models in the collection
+    # @rbs *options: untyped
+    # @rbs return: Quo::Query
+    def preload: (*untyped options) -> Quo::Query
+
+    # Alias for `preload`
+    # @rbs *options: untyped
+    # @rbs return: Quo::Query
+    def includes: (*untyped options) -> Quo::Query
+
+    private
+
+    @_rel_preload: untyped?
+
+    # @rbs (untyped records, ?untyped? preload) -> untyped
+    def preload_includes: (untyped records, ?untyped? preload) -> untyped
+  end
+end

data/sig/generated/quo/query.rbs

@@ -0,0 +1,98 @@
+# Generated from lib/quo/query.rb with RBS::Inline
+
+module Quo
+  class Query < Literal::Struct
+    include Literal::Types
+
+    def self.inspect: () -> untyped
+
+    def self.to_s: () -> untyped
+
+    def inspect: () -> untyped
+
+    def to_s: () -> untyped
+
+    # TODO: put this in a module with the composer and merge_instances methods
+    # Compose is aliased as `+`. Can optionally take `joins` parameters to add joins on merged relation.
+    # @rbs right: Quo::Query | ActiveRecord::Relation | Object & Enumerable[untyped]
+    # @rbs joins: Symbol | Hash[Symbol, untyped] | Array[Symbol | Hash[Symbol, untyped]]
+    # @rbs return: Quo::Query & Quo::ComposedQuery
+    def self.compose: (Quo::Query | ActiveRecord::Relation | Object & Enumerable[untyped] right, ?joins: Symbol | Hash[Symbol, untyped] | Array[Symbol | Hash[Symbol, untyped]]) -> (Quo::Query & Quo::ComposedQuery)
+
+    COERCE_TO_INT: untyped
+
+    attr_accessor page(): Integer?
+
+    attr_accessor page_size(): Integer?
+
+    @current_page: Integer?
+
+    def next_page_query: () -> Quo::Query
+
+    def previous_page_query: () -> Quo::Query
+
+    def offset: () -> Integer
+
+    # Returns a active record query, or a Quo::Query instance
+    def query: () -> (Quo::Query | ::ActiveRecord::Relation)
+
+    # @rbs **overrides: untyped
+    # @rbs return: Quo::Query
+    def copy: (**untyped overrides) -> Quo::Query
+
+    # Compose is aliased as `+`. Can optionally take `joins` parameters to add joins on merged relation.
+    # @rbs right: Quo::Query | ::ActiveRecord::Relation
+    # @rbs joins: untyped
+    # @rbs return: Quo::ComposedQuery
+    def merge: (Quo::Query | ::ActiveRecord::Relation right, ?joins: untyped) -> Quo::ComposedQuery
+
+    @__transformer: nil | ^(untyped, ?Integer) -> untyped
+
+    # Set a block used to transform data after query fetching
+    # @rbs block: ^(untyped, ?Integer) -> untyped
+    # @rbs return: self
+    def transform: () ?{ (?) -> untyped } -> self
+
+    # Is this query object a ActiveRecord relation under the hood?
+    def relation?: () -> bool
+
+    # Is this query object loaded data/collection under the hood? (ie not a AR relation)
+    def collection?: () -> bool
+
+    # Is this query object paged? (ie is paging enabled)
+    def paged?: () -> bool
+
+    # Is this query object transforming results?
+    def transform?: () -> bool
+
+    # Unwrap the paginated query
+    def unwrap: () -> ActiveRecord::Relation
+
+    # Unwrap the un-paginated query
+    def unwrap_unpaginated: () -> ActiveRecord::Relation
+
+    private
+
+    def transformer: () -> untyped
+
+    def validated_query: () -> untyped
+
+    # The underlying query is essentially the configured query with optional extras setup
+    def underlying_query: () -> void
+
+    # The configured query is the underlying query with paging
+    def configured_query: () -> void
+
+    def sanitised_page_size: () -> Integer
+
+    # @rbs rel: untyped
+    # @rbs return: bool
+    def is_collection?: (untyped rel) -> bool
+
+    # @rbs rel: untyped
+    # @rbs return: bool
+    def test_relation: (untyped rel) -> bool
+
+    def quo_unwrap_unpaginated_query: (untyped q) -> untyped
+  end
+end

data/sig/generated/quo/relation_backed_query.rbs

@@ -0,0 +1,67 @@
+# Generated from lib/quo/relation_backed_query.rb with RBS::Inline
+
+module Quo
+  class RelationBackedQuery < Query
+    # @rbs query: ActiveRecord::Relation | Quo::Query
+    # @rbs props: Hash[Symbol, untyped]
+    # @rbs &block: () -> ActiveRecord::Relation | Quo::Query | Object & Enumerable[untyped]
+    # @rbs return: Quo::RelationBackedQuery
+    def self.wrap: (?ActiveRecord::Relation | Quo::Query query, ?props: Hash[Symbol, untyped]) ?{ (?) -> untyped } -> Quo::RelationBackedQuery
+
+    # @rbs conditions: untyped?
+    # @rbs return: String
+    def self.sanitize_sql_for_conditions: (untyped? conditions) -> String
+
+    # @rbs string: String
+    # @rbs return: String
+    def self.sanitize_sql_string: (String string) -> String
+
+    # @rbs value: untyped
+    # @rbs return: String
+    def self.sanitize_sql_parameter: (untyped value) -> String
+
+    @_specification: Quo::RelationBackedQuerySpecification?
+
+    # Apply a query specification to this query
+    # @rbs specification: Quo::RelationBackedQuerySpecification
+    # @rbs return: Quo::Query
+    def with_specification: (Quo::RelationBackedQuerySpecification specification) -> Quo::Query
+
+    # Apply query options using the specification
+    # @rbs options: Hash[Symbol, untyped]
+    # @rbs return: Quo::Query
+    def with: (?Hash[Symbol, untyped] options) -> Quo::Query
+
+    # @rbs return: Quo::CollectionBackedQuery
+    def to_collection: (?total_count: untyped) -> Quo::CollectionBackedQuery
+
+    def results: () -> Quo::Results
+
+    # Return the SQL string for this query if its a relation type query object
+    def to_sql: () -> String
+
+    # Implements a fluent API for query methods
+    # This allows methods to be chained like query.where(...).order(...).limit(...)
+    # @rbs method_name: Symbol
+    # @rbs *args: untyped
+    # @rbs **kwargs: untyped
+    # @rbs &block: untyped
+    # @rbs return: Quo::Query
+    def method_missing: (Symbol method_name, *untyped args, **untyped kwargs) ?{ (?) -> untyped } -> Quo::Query
+
+    # @rbs method_name: Symbol
+    # @rbs include_private: bool
+    # @rbs return: bool
+    def respond_to_missing?: (Symbol method_name, ?bool include_private) -> bool
+
+    private
+
+    def validated_query: () -> untyped
+
+    # The underlying query is essentially the configured query with optional extras setup
+    def underlying_query: () -> ActiveRecord::Relation
+
+    # The configured query is the underlying query with paging
+    def configured_query: () -> ActiveRecord::Relation
+  end
+end

data/sig/generated/quo/relation_backed_query_specification.rbs

@@ -0,0 +1,94 @@
+# Generated from lib/quo/relation_backed_query_specification.rb with RBS::Inline
+
+module Quo
+  # RelationBackedQuerySpecification encapsulates all the options for building a SQL query
+  # This separates the storage of query options from the actual query construction
+  # and provides a cleaner interface for RelationBackedQuery
+  class RelationBackedQuerySpecification
+    # @rbs!
+    #   @options: Hash[Symbol, untyped]
+    attr_reader options: untyped
+
+    # @rbs options: Hash[Symbol, untyped]
+    def initialize: (?Hash[Symbol, untyped] options) -> untyped
+
+    # Creates a new specification with merged options
+    # @rbs new_options: Hash[Symbol, untyped]
+    # @rbs return: Quo::QuerySpecification
+    def merge: (Hash[Symbol, untyped] new_options) -> Quo::QuerySpecification
+
+    # Apply all the specification options to the given ActiveRecord relation
+    # @rbs relation: ActiveRecord::Relation
+    # @rbs return: ActiveRecord::Relation
+    def apply_to: (ActiveRecord::Relation relation) -> ActiveRecord::Relation
+
+    # @rbs *fields: untyped
+    # @rbs return: Quo::QuerySpecification
+    def select: (*untyped fields) -> Quo::QuerySpecification
+
+    # @rbs conditions: untyped
+    # @rbs return: Quo::QuerySpecification
+    def where: (untyped conditions) -> Quo::QuerySpecification
+
+    # @rbs order_clause: untyped
+    # @rbs return: Quo::QuerySpecification
+    def order: (untyped order_clause) -> Quo::QuerySpecification
+
+    # @rbs *columns: untyped
+    # @rbs return: Quo::QuerySpecification
+    def group: (*untyped columns) -> Quo::QuerySpecification
+
+    # @rbs value: Integer
+    # @rbs return: Quo::QuerySpecification
+    def limit: (Integer value) -> Quo::QuerySpecification
+
+    # @rbs value: Integer
+    # @rbs return: Quo::QuerySpecification
+    def offset: (Integer value) -> Quo::QuerySpecification
+
+    # @rbs tables: untyped
+    # @rbs return: Quo::QuerySpecification
+    def joins: (untyped tables) -> Quo::QuerySpecification
+
+    # @rbs tables: untyped
+    # @rbs return: Quo::QuerySpecification
+    def left_outer_joins: (untyped tables) -> Quo::QuerySpecification
+
+    # @rbs *associations: untyped
+    # @rbs return: Quo::QuerySpecification
+    def includes: (*untyped associations) -> Quo::QuerySpecification
+
+    # @rbs *associations: untyped
+    # @rbs return: Quo::QuerySpecification
+    def preload: (*untyped associations) -> Quo::QuerySpecification
+
+    # @rbs *associations: untyped
+    # @rbs return: Quo::QuerySpecification
+    def eager_load: (*untyped associations) -> Quo::QuerySpecification
+
+    # @rbs enabled: bool
+    # @rbs return: Quo::QuerySpecification
+    def distinct: (?bool enabled) -> Quo::QuerySpecification
+
+    # @rbs order_clause: untyped
+    # @rbs return: Quo::QuerySpecification
+    def reorder: (untyped order_clause) -> Quo::QuerySpecification
+
+    # @rbs *modules: untyped
+    # @rbs return: Quo::QuerySpecification
+    def extending: (*untyped modules) -> Quo::QuerySpecification
+
+    # @rbs *args: untyped
+    # @rbs return: Quo::QuerySpecification
+    def unscope: (*untyped args) -> Quo::QuerySpecification
+
+    # Builds a new specification from a hash of options
+    # @rbs options: Hash[Symbol, untyped]
+    # @rbs return: Quo::QuerySpecification
+    def self.build: (?Hash[Symbol, untyped] options) -> Quo::QuerySpecification
+
+    # Returns a blank specification
+    # @rbs return: Quo::QuerySpecification
+    def self.blank: () -> Quo::QuerySpecification
+  end
+end

data/sig/generated/quo/relation_results.rbs

@@ -0,0 +1,38 @@
+# Generated from lib/quo/relation_results.rb with RBS::Inline
+
+module Quo
+  class RelationResults < Results
+    # @rbs query: Quo::Query
+    # @rbs transformer: (^(untyped, ?Integer) -> untyped)?
+    # @rbs return: void
+    def initialize: (Quo::Query query, ?transformer: (^(untyped, ?Integer) -> untyped)?) -> void
+
+    # Are there any results for this query?
+    def exists?: () -> bool
+
+    # Gets the count of all results ignoring the current page and page size (if set).
+    def total_count: () -> Integer
+
+    # Gets the actual count of elements in the page of results (assuming paging is being used, otherwise the count of
+    # all results)
+    def page_count: () -> Integer
+
+    private
+
+    @query: Quo::RelationBackedQuery
+
+    @configured_query: ActiveRecord::Relation
+
+    # Note we reselect the query as this prevents query errors if the SELECT clause is not compatible with COUNT
+    # (SQLException: wrong number of arguments to function COUNT()). We do this in two ways, either with the primary key
+    # or with Arel.star. The primary key is the most compatible way to count, but if the query does not have a primary
+    # we fallback. The fallback "*" wont work in certain situations though, specifically if we have a limit() on the query
+    # which Arel constructs as a subquery. In this case we will get a SQL error as the generated SQL contains
+    # `SELECT COUNT(count_column) FROM (SELECT * AS count_column FROM ...) subquery_for_count` where the error is:
+    # `ActiveRecord::StatementInvalid: SQLite3::SQLException: near "AS": syntax error`
+    # Either way DB engines know how to count efficiently.
+    # @rbs query: ActiveRecord::Relation
+    # @rbs return: Integer
+    def count_query: (ActiveRecord::Relation query) -> Integer
+  end
+end

data/sig/generated/quo/results.rbs

@@ -0,0 +1,39 @@
+# Generated from lib/quo/results.rb with RBS::Inline
+
+module Quo
+  class Results
+    def empty?: () -> bool
+
+    # Alias for total_count
+    def count: () -> Integer
+
+    # Alias for total_count
+    def size: () -> Integer
+
+    # Alias for page_count
+    def page_size: () -> Integer
+
+    # @rbs &block: (untyped, *untyped) -> untyped
+    # @rbs return: Hash[untyped, Array[untyped]]
+    def group_by: () { (untyped, *untyped) -> untyped } -> Hash[untyped, Array[untyped]]
+
+    # Delegate other enumerable methods to underlying collection but also transform
+    # @rbs override
+    def method_missing: ...
+
+    # @rbs name: Symbol
+    # @rbs include_private: bool
+    # @rbs return: bool
+    def respond_to_missing?: (Symbol name, ?bool include_private) -> bool
+
+    def transform?: () -> bool
+
+    private
+
+    @transformer: (^(untyped, ?Integer) -> untyped)?
+
+    # @rbs results: untyped
+    # @rbs return: untyped
+    def transform_results: (untyped results) -> untyped
+  end
+end

data/sig/generated/quo/testing/collection_backed_fake.rbs

@@ -0,0 +1,13 @@
+# Generated from lib/quo/testing/collection_backed_fake.rb with RBS::Inline
+
+module Quo
+  module Testing
+    class CollectionBackedFake
+      def collection: () -> untyped
+
+      def results: () -> untyped
+
+      def page_count: () -> untyped
+    end
+  end
+end

data/sig/generated/quo/testing/relation_backed_fake.rbs

@@ -0,0 +1,23 @@
+# Generated from lib/quo/testing/relation_backed_fake.rb with RBS::Inline
+
+module Quo
+  module Testing
+    class RelationBackedFake
+      def query: () -> untyped
+
+      def results: () -> untyped
+
+      def page_count: () -> untyped
+
+      def total_count: () -> untyped
+
+      private
+
+      def validated_query: () -> untyped
+
+      def underlying_query: () -> untyped
+
+      def configured_query: () -> untyped
+    end
+  end
+end

data/sig/generated/quo/version.rbs

@@ -0,0 +1,5 @@
+# Generated from lib/quo/version.rb with RBS::Inline
+
+module Quo
+  VERSION: ::String
+end

data/sig/generated/quo.rbs

@@ -0,0 +1,9 @@
+# Generated from lib/quo.rb with RBS::Inline
+
+module Quo
+  extend ActiveSupport::Autoload
+
+  def self.relation_backed_query_base_class: () -> Quo::RelationBackedQuery
+
+  def self.collection_backed_query_base_class: () -> Quo::CollectionBackedQuery
+end

data/sig/literal.rbs

@@ -0,0 +1,7 @@
+module Literal
+  class Struct
+  end
+
+  module Types
+  end
+end