rails-on-sorbet 0.2.7 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c4cb80ad204ac1ff75b170054b6c3722eaab381d2c707eaa04e9ae937bc7e39
-  data.tar.gz: 2796d4d8a2ac13e1d30618aa60016208201349df01f4ebcdf8d4af3fd84fe020
+  metadata.gz: fe4169663fb8997f73abd67b1c4194a1f74ec2feacd2d852e1591e6de8c10edc
+  data.tar.gz: b2e5dbb4522948405d21ab34fb0bb6ed5efdbe1ca75f58098a190030b8de3615
 SHA512:
-  metadata.gz: c30c27cc7e051c159e5f8af119cc48862410974a4808af8dac082d3a9be5aa56802bf5aa9c12d13ba43d274a554f33dd88fc65c60a181ab46089a95d07206d59
-  data.tar.gz: fd0d8cdd737a867e9fe269a76823626b1040f643710e7aa56090b39411eaed24310d9d11bcc7593de9c8c03d4c5ca3aa5d430302c5fea0cea3f6ce505449f515
+  metadata.gz: c0591ea92aef3fa4fd12eec00ad5f8fd8239b7caf94619bf80d0f0fe69568fa23a99eab69b2ab5c049efa1dc178021c3ee88acc0a2b877bdf03d50d0fa9f0f3d
+  data.tar.gz: eea1bbe85c46586953ab218ef0398d122568109f0c8d67a710d348323f696d753e8360b8d48ac97175907294010e1ff9145f13e0667da8eb586cef7a44df2b06

data/CHANGELOG.md

@@ -12,6 +12,20 @@ Add changes in new features here. Do not change the gem's version in pull/merge
 ### Changes
 -
 
+## [0.3.0] - 20.10.2025
+
+[Diff](https://github.com/espago/rails-on-sorbet/compare/v0.2.8...v0.3.0)
+
+### Changes
+- Add `TypedRelation` and `TypedAssociation` for better ActiveRecord::Relation sorbet handling
+
+## [0.2.8] - 16.10.2025
+
+[Diff](https://github.com/espago/rails-on-sorbet/compare/v0.2.7...v0.2.8)
+
+### Changes
+- Add missing `Map#each` method
+
 ## [0.2.7] - 08.10.2025
 
 [Diff](https://github.com/espago/rails-on-sorbet/compare/v0.2.6...v0.2.7)

data/README.md

@@ -85,6 +85,62 @@ m = Map(params) #=> Map[String, untyped]
 foo(m) # OK
 ```
 
+### TypedRelation
+
+Sorbet lacks proper generic handling of `ActiveRecord::Relation`.
+The class itself is not generic and tapioca generates a bunch of classes like `X::PrivateRelation`, `X::PrivateAssociationRelation`, `X::PrivateCollectionProxy` per model but these classes have no common generic ancestors which makes them incredibly finnicky to work with.
+
+Because of that we introduced a bunch of interfaces:
+- `TypedRelation` is included by per-model classes like `X::PrivateRelation`
+- `TypedAssociation::Relation` is included by per-model classes like `X::PrivateAssociationRelation`
+- `TypedAssociation::CollectionProxy` is included by per-model classes like `X::PrivateCollectionProxy`
+
+Example:
+```rb
+class Foo < ActiveRecord::Base
+  has_many :bars
+end
+
+foo = Foo.new
+foo.bars #=> Bar::PrivateCollectionProxy
+
+#: (TypedAssociation::CollectionProxy[Bar]) -> void
+def do_smth(rel); end
+
+do_smth(foo.bars) # ok!
+```
+
+One common use case is working on child/parent model associations.
+
+```rb
+class Foo < ActiveRecord::Base
+  belongs_to :user
+end
+
+class Bar < Foo
+  belongs_to :manager
+end
+
+class User < ActiveRecord::Base
+  has_many :foos
+end
+
+class Manager < ActiveRecord::Base
+  has_many :bars
+end
+
+#: (TypedAssociation::CollectionProxy[Foo]) -> void
+def do_smth_on_foos(rel); end
+
+user = User.new
+user.foos #=> Foo::PrivateCollectionProxy
+do_smth_on_foos(user.foos) # ok!
+
+user = Manager.new
+user.bars #=> Bar::PrivateCollectionProxy
+do_smth_on_foos(user.bars) # ok!
+```
+
 ### ActiveRecord::Base::alias_association
 
 This gem adds a new method called `alias_association` on ActiveRecord classes.
@@ -92,13 +148,13 @@ It lets you define aliases for getters and setters of `belongs_to` and `has_one`
 
 Example:
 ```rb
-  class Foo < ApplicationRecord
-    belongs_to :user
-    alias_association :owner, :user
-  end
+class Foo < ApplicationRecord
+  belongs_to :user
+  alias_association :owner, :user
+end
 
-  f = Foo.last
-  f.owner == f.user #=> true
+f = Foo.last
+f.owner == f.user #=> true
 ```
 
 ### Rails::On::Sorbet::CurrentAttributes

data/lib/rails/on/sorbet/typed_relation.rb

@@ -0,0 +1,58 @@
+# typed: false
+# frozen_string_literal: true
+
+require 'action_controller'
+require 'active_support'
+
+# Represents a `X::PrivateRelation` tapioca generated class, where `X` is an ActiveRecord model.
+module TypedRelation
+  extend T::Generic
+
+  class << self
+    def GroupChain(val) = val # rubocop:disable Naming/MethodName
+    def WhereChain(val) = val # rubocop:disable Naming/MethodName
+  end
+
+  module GroupChain
+    extend T::Generic
+    include TypedRelation
+  end
+
+  module WhereChain
+    extend T::Generic
+  end
+end
+
+def TypedRelation(val) = val # rubocop:disable Style/TopLevelMethodDefinition,Naming/MethodName
+
+# A namespace for typed ActiveRecord association objects.
+module TypedAssociation
+  class << self
+    def Relation(val) = val # rubocop:disable Naming/MethodName
+    def CollectionProxy(val) = val # rubocop:disable Naming/MethodName
+  end
+
+  # Represents a `X::PrivateAssociationRelation` tapioca generated class, where `X` is an ActiveRecord model.
+  module Relation
+    extend T::Generic
+
+    class << self
+      def GroupChain(val) = val # rubocop:disable Naming/MethodName
+      def WhereChain(val) = val # rubocop:disable Naming/MethodName
+      def CollectionProxy(val) = val # rubocop:disable Naming/MethodName
+    end
+
+    module GroupChain
+      extend T::Generic
+      include Relation
+    end
+
+    module WhereChain
+      extend T::Generic
+    end
+  end
+
+  module CollectionProxy
+    extend T::Generic
+  end
+end

data/lib/rails/on/sorbet/version.rb

@@ -3,7 +3,7 @@
 module Rails
   module On
     module Sorbet
-      VERSION = '0.2.7'
+      VERSION = '0.3.0'
     end
   end
 end

data/lib/tapioca/dsl/compilers/rails_on_sorbet_active_record.rb

@@ -0,0 +1,49 @@
+# typed: true
+# frozen_string_literal: true
+
+module Tapioca
+  module Compilers
+    # Creates .rbi files with types for classes that use ActiveRecord relations
+    #: [ConstantType < singleton(::ActiveRecord::Base)]
+    class RailsOnSorbetActiveRecordRelations < Tapioca::Dsl::Compiler
+      class << self
+        # @override
+        #: -> T::Enumerable[Module]
+        def gather_constants
+          all_classes.select do |klass|
+            klass < ::ActiveRecord::Base
+          end
+        end
+      end
+
+      # @override
+      #: -> void
+      def decorate
+        root.create_path(constant) do |klass|
+          private_relation = klass.create_class('PrivateRelation')
+          private_relation.create_include('::TypedRelation')
+
+          private_relation_group_chain = klass.create_class('PrivateRelationGroupChain')
+          private_relation_group_chain.create_include('::TypedRelation::GroupChain')
+
+          private_relation_where_chain = klass.create_class('PrivateRelationWhereChain')
+          private_relation_where_chain.create_include('::TypedRelation::WhereChain')
+
+          private_collection_proxy = klass.create_class('PrivateCollectionProxy')
+          private_collection_proxy.create_include('::TypedRelation::CollectionProxy')
+
+
+          private_association_relation = klass.create_class('PrivateAssociationRelation')
+          private_association_relation.create_include('::TypedAssociationRelation')
+
+          private_relation_group_chain = klass.create_class('PrivateAssociationRelationGroupChain')
+          private_relation_group_chain.create_include('::TypedAssociationRelation::GroupChain')
+
+          private_relation_where_chain = klass.create_class('PrivateAssociationRelationWhereChain')
+          private_relation_where_chain.create_include('::TypedAssociationRelation::WhereChain')
+        end
+      end
+
+    end
+  end
+end

data/rbi/map.rbi

@@ -87,6 +87,31 @@ module Map
   sig {abstract.returns(T::Enumerator[K])}
   def each_key(&blk); end
 
+  # Calls *block* once for each key in *hsh*, passing the key-value pair as
+  # parameters.
+  #
+  # If no block is given, an enumerator is returned instead.
+  #
+  # ```ruby
+  # h = { "a" => 100, "b" => 200 }
+  # h.each {|key, value| puts "#{key} is #{value}" }
+  # ```
+  #
+  # *produces:*
+  #
+  # ```ruby
+  # a is 100
+  # b is 200
+  # ```
+  sig do
+    abstract.params(
+        blk: T.proc.params(arg0: [K, V]).returns(BasicObject),
+    )
+    .returns(T::Hash[K, V])
+  end
+  sig {returns(T::Enumerator[[K, V]])}
+  def each(&blk); end
+
   # Returns `true` if the given key is present in *hsh*.
   #
   # ```ruby

data/rbi/typed_relation.rbi

@@ -0,0 +1,944 @@
+# typed: false
+
+#: (ActiveRecord::Relation) -> TypedRelation[untyped]
+def TypedRelation(val); end
+
+# @abstract
+module TypedCommonRelationMethods
+  Elem = type_member(:out)
+
+  # START CommonRelationMethods
+
+  sig { abstract.returns(T::Array[Elem]) }
+  def to_a; end
+
+  sig { abstract.returns(T::Array[Elem]) }
+  def to_ary; end
+
+  sig do
+    abstract.params(
+      block: T.nilable(T.proc.params(record: Elem).returns(T.untyped))
+    ).returns(T::Boolean)
+  end
+  def any?(&block); end
+
+  sig { abstract.params(column_name: T.any(String, Symbol)).returns(T.any(Integer, Float, BigDecimal)) }
+  def average(column_name); end
+
+  sig do
+    params(
+      block: T.nilable(T.proc.params(object: Elem).void)
+    ).returns(Elem)
+  end
+  sig do
+    params(
+      attributes: T::Array[T.untyped],
+      block: T.nilable(T.proc.params(object: Elem).void)
+    ).returns(T::Array[Elem])
+  end
+  sig do
+    params(
+      attributes: T.untyped,
+      block: T.nilable(T.proc.params(object: Elem).void)
+    ).returns(Elem)
+  end
+  def build(attributes = nil, &block); end
+
+  sig { abstract.params(operation: Symbol, column_name: T.any(String, Symbol)).returns(T.any(Integer, Float, BigDecimal)) }
+  def calculate(operation, column_name); end
+
+  sig { params(column_name: T.nilable(T.any(String, Symbol))).returns(Integer) }
+  sig do
+    params(
+      column_name: NilClass,
+      block: T.proc.params(object: Elem).void
+    ).returns(Integer)
+  end
+  def count(column_name = nil, &block); end
+
+  sig do
+    params(
+      block: T.nilable(T.proc.params(object: Elem).void)
+    ).returns(Elem)
+  end
+  sig do
+    params(
+      attributes: T::Array[T.untyped],
+      block: T.nilable(T.proc.params(object: Elem).void)
+    ).returns(T::Array[Elem])
+  end
+  sig do
+    params(
+      attributes: T.untyped,
+      block: T.nilable(T.proc.params(object: Elem).void)
+    ).returns(Elem)
+  end
+  def create(attributes = nil, &block); end
+
+  sig do
+    params(
+      block: T.nilable(T.proc.params(object: Elem).void)
+    ).returns(Elem)
+  end
+  sig do
+    params(
+      attributes: T::Array[T.untyped],
+      block: T.nilable(T.proc.params(object: Elem).void)
+    ).returns(T::Array[Elem])
+  end
+  sig do
+    params(
+      attributes: T.untyped,
+      block: T.nilable(T.proc.params(object: Elem).void)
+    ).returns(Elem)
+  end
+  def create!(attributes = nil, &block); end
+
+  sig do
+    params(
+      attributes: T::Array[T.untyped],
+      block: T.nilable(T.proc.params(object: Elem).void)
+    ).returns(T::Array[Elem])
+  end
+  sig do
+    params(
+      attributes: T.untyped,
+      block: T.nilable(T.proc.params(object: Elem).void)
+    ).returns(Elem)
+  end
+  def create_or_find_by(attributes, &block); end
+
+  sig do
+    params(
+      attributes: T::Array[T.untyped],
+      block: T.nilable(T.proc.params(object: Elem).void)
+    ).returns(T::Array[Elem])
+  end
+  sig do
+    params(
+      attributes: T.untyped,
+      block: T.nilable(T.proc.params(object: Elem).void)
+    ).returns(Elem)
+  end
+  def create_or_find_by!(attributes, &block); end
+
+  sig { returns(T::Array[Elem]) }
+  def destroy_all; end
+
+  sig { params(conditions: T.untyped).returns(T::Boolean) }
+  def exists?(conditions = :none); end
+
+  sig { returns(T.nilable(Elem)) }
+  def fifth; end
+
+  sig { returns(Elem) }
+  def fifth!; end
+
+  sig do
+    params(
+      args: T.any(String, Symbol, ::ActiveSupport::Multibyte::Chars, T::Boolean, BigDecimal, Numeric, ::ActiveRecord::Type::Binary::Data, ::ActiveRecord::Type::Time::Value, Date, Time, ::ActiveSupport::Duration, T::Class[T.anything])
+    ).returns(Elem)
+  end
+  sig do
+    params(
+      args: T::Array[T.any(String, Symbol, ::ActiveSupport::Multibyte::Chars, T::Boolean, BigDecimal, Numeric, ::ActiveRecord::Type::Binary::Data, ::ActiveRecord::Type::Time::Value, Date, Time, ::ActiveSupport::Duration, T::Class[T.anything])]
+    ).returns(T::Enumerable[Elem])
+  end
+  sig do
+    params(
+      args: NilClass,
+      block: T.proc.params(object: Elem).void
+    ).returns(T.nilable(Elem))
+  end
+  def find(args = nil, &block); end
+
+  sig { params(args: T.untyped).returns(T.nilable(Elem)) }
+  def find_by(*args); end
+
+  sig { params(args: T.untyped).returns(Elem) }
+  def find_by!(*args); end
+
+  sig do
+    params(
+      start: T.untyped,
+      finish: T.untyped,
+      batch_size: Integer,
+      error_on_ignore: T.untyped,
+      order: Symbol,
+      block: T.proc.params(object: Elem).void
+    ).void
+  end
+  sig do
+    params(
+      start: T.untyped,
+      finish: T.untyped,
+      batch_size: Integer,
+      error_on_ignore: T.untyped,
+      order: Symbol
+    ).returns(T::Enumerator[Elem])
+  end
+  def find_each(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, order: :asc, &block); end
+
+  sig do
+    params(
+      start: T.untyped,
+      finish: T.untyped,
+      batch_size: Integer,
+      error_on_ignore: T.untyped,
+      order: Symbol,
+      block: T.proc.params(object: T::Array[Elem]).void
+    ).void
+  end
+  sig do
+    params(
+      start: T.untyped,
+      finish: T.untyped,
+      batch_size: Integer,
+      error_on_ignore: T.untyped,
+      order: Symbol
+    ).returns(T::Enumerator[T::Enumerator[Elem]])
+  end
+  def find_in_batches(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, order: :asc, &block); end
+
+  sig do
+    params(
+      attributes: T::Array[T.untyped],
+      block: T.nilable(T.proc.params(object: Elem).void)
+    ).returns(T::Array[Elem])
+  end
+  sig do
+    params(
+      attributes: T.untyped,
+      block: T.nilable(T.proc.params(object: Elem).void)
+    ).returns(Elem)
+  end
+  def find_or_create_by(attributes, &block); end
+
+  sig do
+    params(
+      attributes: T::Array[T.untyped],
+      block: T.nilable(T.proc.params(object: Elem).void)
+    ).returns(T::Array[Elem])
+  end
+  sig do
+    params(
+      attributes: T.untyped,
+      block: T.nilable(T.proc.params(object: Elem).void)
+    ).returns(Elem)
+  end
+  def find_or_create_by!(attributes, &block); end
+
+  sig do
+    params(
+      attributes: T::Array[T.untyped],
+      block: T.nilable(T.proc.params(object: Elem).void)
+    ).returns(T::Array[Elem])
+  end
+  sig do
+    params(
+      attributes: T.untyped,
+      block: T.nilable(T.proc.params(object: Elem).void)
+    ).returns(Elem)
+  end
+  def find_or_initialize_by(attributes, &block); end
+
+  sig do
+    abstract.params(
+      signed_id: T.untyped,
+      purpose: T.untyped
+    ).returns(T.nilable(Elem))
+  end
+  def find_signed(signed_id, purpose: nil); end
+
+  sig { abstract.params(signed_id: T.untyped, purpose: T.untyped).returns(Elem) }
+  def find_signed!(signed_id, purpose: nil); end
+
+  sig { abstract.params(arg: T.untyped, args: T.untyped).returns(Elem) }
+  def find_sole_by(arg, *args); end
+
+  sig { returns(T.nilable(Elem)) }
+  sig { params(limit: Integer).returns(T::Array[Elem]) }
+  def first(limit = nil); end
+
+  sig { abstract.returns(Elem) }
+  def first!; end
+
+  sig { abstract.returns(T.nilable(Elem)) }
+  def forty_two; end
+
+  sig { abstract.returns(Elem) }
+  def forty_two!; end
+
+  sig { abstract.returns(T.nilable(Elem)) }
+  def fourth; end
+
+  sig { abstract.returns(Elem) }
+  def fourth!; end
+
+  sig { abstract.returns(Array) }
+  def ids; end
+
+  sig do
+    params(
+      of: Integer,
+      start: T.untyped,
+      finish: T.untyped,
+      load: T.untyped,
+      error_on_ignore: T.untyped,
+      order: Symbol,
+      use_ranges: T.untyped,
+      block: T.proc.params(object: T.untyped).void
+    ).void
+  end
+  sig do
+    params(
+      of: Integer,
+      start: T.untyped,
+      finish: T.untyped,
+      load: T.untyped,
+      error_on_ignore: T.untyped,
+      order: Symbol,
+      use_ranges: T.untyped
+    ).returns(::ActiveRecord::Batches::BatchEnumerator)
+  end
+  def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, order: :asc, use_ranges: nil, &block); end
+
+  sig { abstract.params(record: T.untyped).returns(T::Boolean) }
+  def include?(record); end
+
+  sig { returns(T.nilable(Elem)) }
+  sig { params(limit: Integer).returns(T::Array[Elem]) }
+  def last(limit = nil); end
+
+  sig { returns(Elem) }
+  def last!; end
+
+  sig do
+    abstract.params(
+      block: T.nilable(T.proc.params(record: Elem).returns(T.untyped))
+    ).returns(T::Boolean)
+  end
+  def many?(&block); end
+
+  sig { abstract.params(column_name: T.any(String, Symbol)).returns(T.untyped) }
+  def maximum(column_name); end
+
+  sig { abstract.params(record: T.untyped).returns(T::Boolean) }
+  def member?(record); end
+
+  sig { abstract.params(column_name: T.any(String, Symbol)).returns(T.untyped) }
+  def minimum(column_name); end
+
+  sig do
+    params(
+      block: T.nilable(T.proc.params(object: Elem).void)
+    ).returns(Elem)
+  end
+  sig do
+    params(
+      attributes: T::Array[T.untyped],
+      block: T.nilable(T.proc.params(object: Elem).void)
+    ).returns(T::Array[Elem])
+  end
+  sig do
+    params(
+      attributes: T.untyped,
+      block: T.nilable(T.proc.params(object: Elem).void)
+    ).returns(Elem)
+  end
+  def new(attributes = nil, &block); end
+
+  sig do
+    abstract.params(
+      block: T.nilable(T.proc.params(record: Elem).returns(T.untyped))
+    ).returns(T::Boolean)
+  end
+  def none?(&block); end
+
+  sig do
+    abstract.params(
+      block: T.nilable(T.proc.params(record: Elem).returns(T.untyped))
+    ).returns(T::Boolean)
+  end
+  def one?(&block); end
+
+  sig { abstract.params(column_names: T.untyped).returns(T.untyped) }
+  def pick(*column_names); end
+
+  sig { abstract.params(column_names: T.untyped).returns(T.untyped) }
+  def pluck(*column_names); end
+
+  sig { abstract.returns(T.nilable(Elem)) }
+  def second; end
+
+  sig { abstract.returns(Elem) }
+  def second!; end
+
+  sig { abstract.returns(T.nilable(Elem)) }
+  def second_to_last; end
+
+  sig { abstract.returns(Elem) }
+  def second_to_last!; end
+
+  sig { abstract.returns(Elem) }
+  def sole; end
+
+  sig { params(initial_value_or_column: T.untyped).returns(T.any(Integer, Float, BigDecimal)) }
+  sig do
+    type_parameters(:U)
+      .params(
+        initial_value_or_column: T.nilable(T.type_parameter(:U)),
+        block: T.proc.params(object: Elem).returns(T.type_parameter(:U))
+      ).returns(T.type_parameter(:U))
+  end
+  def sum(initial_value_or_column = nil, &block); end
+
+  sig { returns(T.nilable(Elem)) }
+  sig { params(limit: Integer).returns(T::Array[Elem]) }
+  def take(limit = nil); end
+
+  sig { abstract.returns(Elem) }
+  def take!; end
+
+  sig { abstract.returns(T.nilable(Elem)) }
+  def third; end
+
+  sig { abstract.returns(Elem) }
+  def third!; end
+
+  sig { abstract.returns(T.nilable(Elem)) }
+  def third_to_last; end
+
+  sig { abstract.returns(Elem) }
+  def third_to_last!; end
+
+  # END CommonRelationMethods
+end
+
+# @abstract
+# @requires_ancestor: ActiveRecord::Relation
+module TypedRelation
+  Elem = type_member(:out)
+
+  class << self
+    #: (ActiveRecord::Relation) -> GroupChain[untyped]
+    def GroupChain(val); end
+    #: (ActiveRecord::QueryMethods::WhereChain) -> WhereChain[untyped]
+    def WhereChain(val); end
+  end
+
+  # @abstract
+  module GroupChain
+    include TypedRelation
+
+    Elem = type_member(:out)
+
+    sig { abstract.params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]) }
+    def average(column_name); end
+
+    sig do
+      abstract.params(
+        operation: Symbol,
+        column_name: T.any(String, Symbol)
+      ).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)])
+    end
+    def calculate(operation, column_name); end
+
+    sig { abstract.params(column_name: T.untyped).returns(T::Hash[T.untyped, Integer]) }
+    def count(column_name = nil); end
+
+    sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+    def having(*args, &blk); end
+
+    sig { abstract.params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) }
+    def maximum(column_name); end
+
+    sig { abstract.params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) }
+    def minimum(column_name); end
+
+    sig { returns(T::Hash[T.untyped, Integer]) }
+    def size; end
+
+    sig do
+      abstract.params(
+        column_name: T.nilable(T.any(String, Symbol)),
+        block: T.nilable(T.proc.params(record: T.untyped).returns(T.untyped))
+      ).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)])
+    end
+    def sum(column_name = nil, &block); end
+  end
+
+  # @requires_ancestor: ::ActiveRecord::QueryMethods::WhereChain
+  # @abstract
+  module WhereChain
+    Elem = type_member(:out)
+
+    sig { abstract.params(args: T.untyped).returns(TypedRelation[Elem]) }
+    def associated(*args); end
+
+    sig { abstract.params(args: T.untyped).returns(TypedRelation[Elem]) }
+    def missing(*args); end
+
+    sig { abstract.params(opts: T.untyped, rest: T.untyped).returns(TypedRelation[Elem]) }
+    def not(opts, *rest); end
+  end
+
+  include TypedCommonRelationMethods
+
+  # START GeneratedRelationMethods
+
+  sig { abstract.returns(T.self_type) }
+  def all; end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def and(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def annotate(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def arel_columns(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def create_with(*args, &blk); end
+
+  sig { abstract.params(value: T::Boolean).returns(T.self_type) }
+  def distinct(value = true); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def eager_load(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def except(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def excluding(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def extending(*args, &blk); end
+
+  sig { abstract.params(association: Symbol).returns(T::Array[T.untyped]) }
+  def extract_associated(association); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def from(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(GroupChain[Elem]) }
+  def group(*args, &blk); end
+
+  sig { params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def having(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def in_order_of(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def includes(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def invert_where(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def joins(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def left_joins(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def left_outer_joins(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def limit(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def lock(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def merge(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def none(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def null_relation?(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def offset(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def only(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def optimizer_hints(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def or(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def order(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def preload(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def readonly(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def references(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def regroup(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def reorder(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def reselect(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def reverse_order(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def rewhere(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def sanitize_forbidden_attributes(*args, &blk); end
+
+  sig { params(args: T.untyped).returns(T.self_type) }
+  sig do
+    params(
+      blk: T.proc.params(record: Elem).returns(BasicObject)
+    ).returns(T::Array[Elem])
+  end
+  def select(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def strict_loading(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def structurally_compatible?(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def uniq!(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def unscope(*args, &blk); end
+
+  sig { returns(WhereChain[Elem]) }
+  sig { params(args: T.untyped).returns(T.self_type) }
+  def where(*args); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def with(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def with_recursive(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def without(*args, &blk); end
+end
+
+# @abstract
+module TypedGeneratedAssociationRelationMethods
+  Elem = type_member(:out)
+
+  sig { abstract.returns(T::Array[Elem]) }
+  def to_a; end
+
+  sig { abstract.returns(T::Array[Elem]) }
+  def to_ary; end
+
+  sig { abstract.returns(T.self_type) }
+  def all; end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def and(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def annotate(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def arel_columns(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def create_with(*args, &blk); end
+
+  sig { abstract.params(value: T::Boolean).returns(T.self_type) }
+  def distinct(value = true); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def eager_load(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def except(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def excluding(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def extending(*args, &blk); end
+
+  sig { abstract.params(association: Symbol).returns(T::Array[T.untyped]) }
+  def extract_associated(association); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def from(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(TypedAssociation::Relation::GroupChain[Elem]) }
+  def group(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def having(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def in_order_of(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def includes(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def invert_where(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def joins(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def left_joins(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def left_outer_joins(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def limit(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def lock(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def merge(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def none(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def null_relation?(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def offset(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def only(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def optimizer_hints(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def or(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def order(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def preload(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def readonly(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def references(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def regroup(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def reorder(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def reselect(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def reverse_order(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def rewhere(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def sanitize_forbidden_attributes(*args, &blk); end
+
+  sig { params(args: T.untyped).returns(T.self_type) }
+  sig do
+    params(
+      blk: T.proc.params(record: Elem).returns(BasicObject)
+    ).returns(T::Array[Elem])
+  end
+  def select(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def strict_loading(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def structurally_compatible?(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def uniq!(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def unscope(*args, &blk); end
+
+  sig { returns(TypedAssociation::Relation::WhereChain[Elem]) }
+  sig { params(args: T.untyped).returns(T.self_type) }
+  def where(*args); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def with(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def with_recursive(*args, &blk); end
+
+  sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+  def without(*args, &blk); end
+end
+
+module TypedAssociation
+  class << self
+    #: (::ActiveRecord::Relation) -> Relation[untyped]
+    def Relation(val); end
+    #: (::ActiveRecord::Associations::CollectionProxy) -> CollectionProxy[untyped]
+    def CollectionProxy(val); end
+  end
+
+  # @abstract
+  # @requires_ancestor: ActiveRecord::AssociationRelation
+  module Relation
+    include TypedCommonRelationMethods
+    include TypedGeneratedAssociationRelationMethods
+
+    Elem = type_member(:out)
+
+    class << self
+      #: (ActiveRecord::Relation) -> GroupChain[untyped]
+      def GroupChain(val); end
+      #: (ActiveRecord::QueryMethods::WhereChain) -> WhereChain[untyped]
+      def WhereChain(val); end
+    end
+
+    # @requires_ancestor: ::ActiveRecord::QueryMethods::WhereChain
+    # @abstract
+    module WhereChain
+      Elem = type_member(:out)
+
+      sig { abstract.params(args: T.untyped).returns(Relation[Elem]) }
+      def associated(*args); end
+
+      sig { abstract.params(args: T.untyped).returns(Relation[Elem]) }
+      def missing(*args); end
+
+      sig { abstract.params(opts: T.untyped, rest: T.untyped).returns(Relation[Elem]) }
+      def not(opts, *rest); end
+    end
+
+    # @abstract
+    module GroupChain
+      include Relation
+
+      Elem = type_member(:out)
+
+      sig { abstract.params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]) }
+      def average(column_name); end
+
+      sig do
+        abstract.params(
+          operation: Symbol,
+          column_name: T.any(String, Symbol)
+        ).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)])
+      end
+      def calculate(operation, column_name); end
+
+      sig { abstract.params(column_name: T.untyped).returns(T::Hash[T.untyped, Integer]) }
+      def count(column_name = nil); end
+
+      sig { abstract.params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+      def having(*args, &blk); end
+
+      sig { abstract.params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) }
+      def maximum(column_name); end
+
+      sig { abstract.params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) }
+      def minimum(column_name); end
+
+      sig { abstract.returns(T::Hash[T.untyped, Integer]) }
+      def size; end
+
+      sig do
+        abstract.params(
+          column_name: T.nilable(T.any(String, Symbol)),
+          block: T.nilable(T.proc.params(record: T.untyped).returns(T.untyped))
+        ).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)])
+      end
+      def sum(column_name = nil, &block); end
+    end
+  end
+
+  # @requires_ancestor: ActiveRecord::Associations::CollectionProxy
+  # @abstract
+  module CollectionProxy
+    include TypedCommonRelationMethods
+    include TypedGeneratedAssociationRelationMethods
+
+    Elem = type_member(:out)
+
+    sig do
+      abstract.params(
+        records: T.any(Elem, T::Enumerable[T.any(Elem, T::Enumerable[Elem])])
+      ).returns(T.self_type)
+    end
+    def <<(*records); end
+
+    sig do
+      abstract.params(
+        records: T.any(Elem, T::Enumerable[T.any(Elem, T::Enumerable[Elem])])
+      ).returns(T.self_type)
+    end
+    def append(*records); end
+
+    sig { abstract.returns(T.self_type) }
+    def clear; end
+
+    sig do
+      abstract.params(
+        records: T.any(Elem, T::Enumerable[T.any(Elem, T::Enumerable[Elem])])
+      ).returns(T.self_type)
+    end
+    def concat(*records); end
+
+    sig { returns(T::Array[Elem]) }
+    def load_target; end
+
+    sig do
+      abstract.params(
+        records: T.any(Elem, T::Enumerable[T.any(Elem, T::Enumerable[Elem])])
+      ).returns(T.self_type)
+    end
+    def prepend(*records); end
+
+    sig do
+      abstract.params(
+        records: T.any(Elem, T::Enumerable[T.any(Elem, T::Enumerable[Elem])])
+      ).returns(T.self_type)
+    end
+    def push(*records); end
+
+    sig do
+      abstract.params(
+        other_array: T.any(Elem, T::Enumerable[T.any(Elem, T::Enumerable[Elem])])
+      ).returns(T::Array[Elem])
+    end
+    def replace(other_array); end
+
+    sig { abstract.returns(TypedAssociation::Relation[Elem]) }
+    def scope; end
+
+    sig { abstract.returns(T::Array[Elem]) }
+    def target; end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-on-sorbet
 version: !ruby/object:Gem::Version
-  version: 0.2.7
+  version: 0.3.0
 platform: ruby
 authors:
 - Mateusz Drewniak
@@ -69,7 +69,9 @@ files:
 - lib/rails/on/sorbet/current_attributes.rb
 - lib/rails/on/sorbet/map.rb
 - lib/rails/on/sorbet/timelike.rb
+- lib/rails/on/sorbet/typed_relation.rb
 - lib/rails/on/sorbet/version.rb
+- lib/tapioca/dsl/compilers/rails_on_sorbet_active_record.rb
 - lib/tapioca/dsl/compilers/rails_on_sorbet_active_record_serializer.rb
 - lib/tapioca/dsl/compilers/rails_on_sorbet_alias_association.rb
 - lib/tapioca/dsl/compilers/rails_on_sorbet_currrent_attributes.rb
@@ -81,6 +83,7 @@ files:
 - rbi/map.rbi
 - rbi/numeric.rbi
 - rbi/set.rbi
+- rbi/typed_relation.rbi
 homepage: https://github.com/espago/rails-on_sorbet
 licenses: []
 metadata: