torque-postgresql 4.1.0 → 4.1.1

data/sig/torque/postgresql/inheritance.rbs

@@ -0,0 +1,47 @@
+module Torque
+  module PostgreSQL
+    class InheritanceError < ArgumentError
+    end
+
+    module Inheritance
+      extend ActiveSupport::Concern
+
+      type dependents = Hash[String, model]
+
+      module ClassMethods
+        def _record_class_attribute: () -> Symbol
+        def _record_class_column_name: () -> String
+        def inheritance_merged_attributes: () -> Array[String]
+        def inheritance_mergeable_attributes: () -> Array[String]
+        def physically_inherited?: () -> bool
+        def inheritance_dependents: () -> Array[String]
+        def physically_inheritances?: () -> bool
+        def inheritance_column_prefix: () -> String
+        def physically_inheritance_root: () -> model
+        def inheritance_foreign_attribute_names: () -> Set[String]
+        def inheritance_dependent_prefixes: () -> Set[String]
+        def casted_dependents: () -> dependents
+        def inheritance_expandable_dependents: () -> dependents
+        def reset_table_name: () -> (String | TableName)
+        def decorated_table_name: () -> String
+        def base_class: () -> model
+        def primary_key: () -> (String | Array[String] | nil)
+        def compute_table_name: () -> (String | TableName)
+        def raise_unable_to_cast: (String record_class_value) -> bot
+        def reload_schema_from_cache: (?bool recursive) -> untyped
+
+        private
+
+        def inheritance_cache: (Symbol name) { () -> untyped } -> untyped
+        def instantiate_instance_of: (model klass, Hash[String, untyped] attributes, ?Hash[String, type_caster] types) ?{ (record) -> void } -> record
+        def sanitize_attributes: (model real_class, Hash[String, untyped] attributes, Hash[String, type_caster] types) -> [Hash[String, untyped], Hash[String, type_caster]]
+      end
+    end
+  end
+end
+
+class ActiveRecord::Base
+  include Torque::PostgreSQL::Inheritance
+  extend Torque::PostgreSQL::Inheritance::ClassMethods
+  include Torque::PostgreSQL::Inheritance::Record
+end

data/sig/torque/postgresql/insert_all.rbs

@@ -0,0 +1,22 @@
+module Torque
+  module PostgreSQL
+    module InsertAll
+      attr_reader where: String | relation | nil
+
+      def initialize: (*untyped args, ?where: String | relation | nil, **untyped xargs) -> void
+
+      module Builder
+        def where: () -> (String | relation | nil)
+        def where_condition?: () -> bool
+      end
+    end
+  end
+end
+
+class ActiveRecord::InsertAll
+  prepend Torque::PostgreSQL::InsertAll
+
+  class Builder
+    include Torque::PostgreSQL::InsertAll::Builder
+  end
+end

data/sig/torque/postgresql/migration/command_recorder.rbs

@@ -0,0 +1,30 @@
+module Torque
+  module PostgreSQL
+    module Migration
+      module CommandRecorder
+        type inversion = [Symbol, Array[untyped]]
+
+        def rename_type: (*untyped args) ?{ (?) -> untyped } -> untyped
+        def invert_rename_type: (Array[untyped] args) ?{ (?) -> untyped } -> inversion
+        def create_composite_type: (*untyped args) ?{ (?) -> untyped } -> untyped
+        def invert_create_composite_type: (Array[untyped] args) ?{ (?) -> untyped } -> inversion
+        def change_composite_type: (*untyped args) ?{ (?) -> untyped } -> untyped
+        def add_composite_column: (*untyped args) ?{ (?) -> untyped } -> untyped
+        def invert_add_composite_column: (Array[untyped] args) ?{ (?) -> untyped } -> inversion
+        def remove_composite_column: (*untyped args) ?{ (?) -> untyped } -> untyped
+        def invert_remove_composite_column: (Array[untyped] args) ?{ (?) -> untyped } -> inversion
+        def change_composite_column: (*untyped args) ?{ (?) -> untyped } -> untyped
+        def rename_composite_column: (*untyped args) ?{ (?) -> untyped } -> untyped
+        def invert_rename_composite_column: (Array[untyped] args) ?{ (?) -> untyped } -> inversion
+        def sync_inheritance_features: (*untyped args) ?{ (?) -> untyped } -> untyped
+        def invert_sync_inheritance_features: (Array[untyped] args) ?{ (?) -> untyped } -> inversion
+        def create_schema: (*untyped args) ?{ (?) -> untyped } -> untyped
+        def invert_create_schema: (Array[untyped] args) ?{ (?) -> untyped } -> inversion
+      end
+    end
+  end
+end
+
+class ActiveRecord::Migration::CommandRecorder
+  include Torque::PostgreSQL::Migration::CommandRecorder
+end

data/sig/torque/postgresql/migration.rbs

@@ -0,0 +1,6 @@
+module Torque
+  module PostgreSQL
+    module Migration
+    end
+  end
+end

data/sig/torque/postgresql/predicate_builder/arel_attribute_handler.rbs

@@ -0,0 +1,15 @@
+module Torque
+  module PostgreSQL
+    module PredicateBuilder
+      class ArelAttributeHandler
+        def self.call: (arel_node attribute, arel_node value) -> arel_node
+        def initialize: (*untyped) -> void
+        def call: (arel_node attribute, arel_node value) -> arel_node
+
+        private
+
+        def array_typed?: (arel_node attribute) -> bool
+      end
+    end
+  end
+end

data/sig/torque/postgresql/predicate_builder/array_handler.rbs

@@ -0,0 +1,26 @@
+module Torque
+  module PostgreSQL
+    module PredicateBuilder
+      module ArrayHandler
+        def call: (arel_node attribute, untyped value) -> arel_node
+        def call_for_array: (arel_node attribute, untyped value) -> arel_node
+
+        private
+
+        def call_with_value: (arel_node attribute, untyped value) -> ::Arel::Nodes::InfixOperation
+        def call_with_array: (arel_node attribute, Array[untyped] value) -> ::Arel::Nodes::InfixOperation
+        def call_with_empty: (arel_node attribute) -> arel_node
+        def id_of: (untyped entry) -> untyped
+        def array_attribute?: (arel_node attribute) -> bool
+      end
+    end
+  end
+end
+
+class ActiveRecord::PredicateBuilder::ArrayHandler
+  prepend Torque::PostgreSQL::PredicateBuilder::ArrayHandler
+end
+
+class ActiveRecord::PredicateBuilder::BasicObjectHandler
+  prepend Torque::PostgreSQL::PredicateBuilder::ArrayHandler
+end

data/sig/torque/postgresql/predicate_builder/composite_handler.rbs

@@ -0,0 +1,26 @@
+module Torque
+  module PostgreSQL
+    module PredicateBuilder
+      class CompositeHandler
+        @predicate_builder: ActiveRecord::PredicateBuilder
+        @composite: Adapter::OID::Composite?
+
+        def self.candidate?: (type_caster? type, ?untyped value) -> bool
+        def self.columns?: (untyped value) -> bool
+        def initialize: (ActiveRecord::PredicateBuilder predicate_builder) -> void
+        def call: (arel_node attribute, type_caster type, untyped value) -> arel_node
+        def table_for: (arel_node source, type_caster type) -> PredicateTable
+        def type_of: (column_ref name) -> [type_caster]
+
+        private
+
+        def predicate_builder: () -> ActiveRecord::PredicateBuilder
+        def composite: () -> Adapter::OID::Composite?
+        def call_for_record: (arel_node attribute, untyped value, bool array) -> arel_node
+        def call_for_array: (arel_node attribute, untyped value) -> arel_node
+        def conditions_for: (arel_node source, untyped value) -> arel_node
+        def group_for: (arel_node source, untyped entry) -> ::Arel::Nodes::Grouping
+      end
+    end
+  end
+end

data/sig/torque/postgresql/predicate_builder/enumerator_lazy_handler.rbs

@@ -0,0 +1,18 @@
+module Torque
+  module PostgreSQL
+    module PredicateBuilder
+      class EnumeratorLazyHandler < ::ActiveRecord::PredicateBuilder::ArrayHandler
+        class Timeout < ::Timeout::Error
+        end
+
+        def call: (arel_attribute attribute, Enumerator::Lazy[untyped, untyped] value) -> arel_node
+
+        private
+
+        def with_timeout: () { () -> arel_node } -> arel_node
+        def timeout: () -> Numeric?
+        def limit: () -> Integer?
+      end
+    end
+  end
+end

data/sig/torque/postgresql/predicate_builder/ltree_handler.rbs

@@ -0,0 +1,36 @@
+module Torque
+  module PostgreSQL
+    module PredicateBuilder
+      class LtreeHandler
+        @predicate_builder: ActiveRecord::PredicateBuilder
+        @attribute: arel_attribute
+        @column: Adapter::OID::Ltree
+        @array: bool
+        @list: bool
+
+        def self.candidate?: (type_caster? type) -> bool
+        def self.column_of: (type_caster? type) -> type_caster?
+        def initialize: (ActiveRecord::PredicateBuilder predicate_builder) -> void
+        def call: (arel_attribute attribute, type_caster type, untyped value) -> arel_node
+
+        private
+
+        def attribute: () -> arel_attribute
+        def column: () -> Adapter::OID::Ltree
+        def array: () -> bool
+        def list: () -> bool
+        def list?: (untyped value) -> bool
+        def lquery_column?: () -> bool
+        def lquery: () -> Adapter::OID::Lquery
+        def ltree: () -> Adapter::OID::Ltree
+        def bind: (untyped value, type_caster type) -> ::Arel::Nodes::BindParam
+        def equality: (Array[untyped] values) -> arel_node
+        def single_equality: (arel_node target, arel_node bind) -> arel_node
+        def empty_equality: (arel_node target) -> arel_node
+        def match: (Array[untyped] values) -> arel_node
+        def single_match: (arel_node bind) -> arel_node
+        def list_match: (arel_node binds) -> arel_node
+      end
+    end
+  end
+end

data/sig/torque/postgresql/predicate_builder/regexp_handler.rbs

@@ -0,0 +1,16 @@
+module Torque
+  module PostgreSQL
+    module PredicateBuilder
+      class RegexpHandler
+        @predicate_builder: ActiveRecord::PredicateBuilder
+
+        def initialize: (ActiveRecord::PredicateBuilder predicate_builder) -> void
+        def call: (arel_attribute attribute, Regexp value) -> ::Arel::Nodes::InfixOperation
+
+        private
+
+        def predicate_builder: () -> ActiveRecord::PredicateBuilder
+      end
+    end
+  end
+end

data/sig/torque/postgresql/predicate_builder/struct_handler.rbs

@@ -0,0 +1,24 @@
+module Torque
+  module PostgreSQL
+    module PredicateBuilder
+      class StructHandler
+        PLAIN_TYPES: Array[Symbol]
+
+        @predicate_builder: ActiveRecord::PredicateBuilder
+        @struct: type_caster?
+
+        def self.candidate?: (type_caster? type, ?untyped value) -> bool
+        def initialize: (ActiveRecord::PredicateBuilder predicate_builder) -> void
+        def call: (arel_node attribute, type_caster struct, Hash[untyped, untyped] value) -> ::Arel::Nodes::Grouping
+        def table_for: (arel_node attribute, type_caster? struct) -> PredicateTable
+        def property_for: (arel_node attribute, type_caster? struct, Array[path_key] path) -> arel_node
+        def type_of: (path_key name) -> [type_caster?, String?]
+
+        private
+
+        def predicate_builder: () -> ActiveRecord::PredicateBuilder
+        def cast_for: (type_caster? type) -> String?
+      end
+    end
+  end
+end

data/sig/torque/postgresql/predicate_builder.rbs

@@ -0,0 +1,23 @@
+module Torque
+  module PostgreSQL
+    # initialize is not declared: the handler files reopen this module before
+    # it is defined, and the runtime checker hooks it eagerly
+    module PredicateBuilder
+      type handler = singleton(CompositeHandler) | singleton(StructHandler) | singleton(LtreeHandler)
+
+      ARRAY_OID: singleton(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array)
+
+      def self.handler_for: (type_caster? type, ?untyped value) -> handler?
+      def build: (arel_node attribute, untyped value, ?Symbol? operator) -> arel_node
+      def resolve_arel_attribute: (column_ref table_name, column_ref column_name) ?{ (?) -> untyped } -> arel_node
+
+      private
+
+      def handler_for_path: (arel_node attribute, untyped value) -> singleton(StructHandler)?
+    end
+  end
+end
+
+class ActiveRecord::PredicateBuilder
+  prepend Torque::PostgreSQL::PredicateBuilder
+end

data/sig/torque/postgresql/predicate_table.rbs

@@ -0,0 +1,24 @@
+module Torque
+  module PostgreSQL
+    class PredicateTable
+      type handler = PredicateBuilder::CompositeHandler | PredicateBuilder::StructHandler
+      type node = Arel::Nodes::Column | Arel::Nodes::Property
+
+      @handler: handler
+      @source: arel_node
+      @node: singleton(::Arel::Nodes::Binary)
+
+      def initialize: (handler handler, arel_node source, singleton(::Arel::Nodes::Binary) node) -> void
+      def arel_table: () -> self
+      def []: (column_ref | Integer name) -> node
+      def type: (column_ref | Integer name) -> type_caster?
+      def has_column?: (*untyped) -> true
+      def primary_key: () -> nil
+      def associated_with: (*untyped) -> false
+      alias associated_with? associated_with
+      def aggregated_with?: (*untyped) -> false
+      def polymorphic_association?: () -> false
+      def through_association?: () -> false
+    end
+  end
+end

data/sig/torque/postgresql/railtie.rbs

@@ -0,0 +1,10 @@
+module Torque
+  module PostgreSQL
+    class Railtie < Rails::Railtie
+    end
+  end
+end
+
+module ActiveRecord::Schema::Definition
+  include Torque::PostgreSQL::Adapter::Definition
+end

data/sig/torque/postgresql/reflection/abstract_reflection.rbs

@@ -0,0 +1,22 @@
+module Torque
+  module PostgreSQL
+    module Reflection
+      module AbstractReflection
+        AREL_ATTR: singleton(::Arel::Attributes::Attribute)
+        AREL_NODE: singleton(::Arel::Nodes::Node)
+
+        def connected_through_array?: () -> bool
+        def join_scope: (table_node table, table_node foreign_table, model | relation foreign_klass) -> relation
+        def build_join_constraint: (table_node table, table_node foreign_table) -> arel_node
+
+        private
+
+        def build_id_constraint_between: (table_node table, table_node foreign_table) -> arel_node
+      end
+    end
+  end
+end
+
+class ActiveRecord::Reflection::AbstractReflection
+  prepend Torque::PostgreSQL::Reflection::AbstractReflection
+end

data/sig/torque/postgresql/reflection/association_reflection.rbs

@@ -0,0 +1,18 @@
+module Torque
+  module PostgreSQL
+    module Reflection
+      module AssociationReflection
+        def initialize: (Symbol name, Proc? scope, Hash[Symbol, untyped] options, model active_record) -> void
+
+        private
+
+        def derive_foreign_key: (*untyped, **untyped) -> String
+        def automatic_inverse_of: () -> Symbol?
+      end
+    end
+  end
+end
+
+class ActiveRecord::Reflection::AssociationReflection
+  prepend Torque::PostgreSQL::Reflection::AssociationReflection
+end

data/sig/torque/postgresql/reflection/belongs_to_many_reflection.rbs

@@ -0,0 +1,30 @@
+module Torque
+  module PostgreSQL
+    module Reflection
+      class BelongsToManyReflection < ::ActiveRecord::Reflection::AssociationReflection
+        @foreign_key: String
+        @association_foreign_key: String
+        @active_record_primary_key: String?
+
+        def macro: () -> :belongs_to_many
+        def connected_through_array?: () -> true
+        def belongs_to?: () -> true
+        def collection?: () -> true
+        def association_class: () -> singleton(Associations::BelongsToManyAssociation)
+        def foreign_key: () -> String
+        def association_foreign_key: () -> String
+        def active_record_primary_key: () -> String?
+        def join_primary_key: (*untyped) -> String?
+        def join_foreign_key: () -> String
+        def array_attribute: () -> arel_attribute
+
+        private
+
+        def derive_primary_key: () -> String?
+        def derive_foreign_key: () -> String
+      end
+    end
+  end
+end
+
+class ActiveRecord::Reflection::BelongsToManyReflection = Torque::PostgreSQL::Reflection::BelongsToManyReflection

data/sig/torque/postgresql/reflection/has_many_reflection.rbs

@@ -0,0 +1,14 @@
+module Torque
+  module PostgreSQL
+    module Reflection
+      module HasManyReflection
+        def connected_through_array?: () -> bool?
+        def array_attribute: () -> arel_attribute
+      end
+    end
+  end
+end
+
+class ActiveRecord::Reflection::HasManyReflection
+  include Torque::PostgreSQL::Reflection::HasManyReflection
+end

data/sig/torque/postgresql/reflection/runtime_reflection.rbs

@@ -0,0 +1,18 @@
+module Torque
+  module PostgreSQL
+    module Reflection
+      module RuntimeReflection
+        def klass: () -> model
+        def active_record: () -> model
+        def connected_through_array?: () -> bool?
+        def macro: () -> Symbol
+        def name: () -> Symbol
+        def array_attribute: () -> arel_attribute
+      end
+    end
+  end
+end
+
+class ActiveRecord::Reflection::RuntimeReflection
+  include Torque::PostgreSQL::Reflection::RuntimeReflection
+end

data/sig/torque/postgresql/reflection/through_reflection.rbs

@@ -0,0 +1,14 @@
+module Torque
+  module PostgreSQL
+    module Reflection
+      module ThroughReflection
+        def build_id_constraint: (*untyped) -> arel_node
+        def connected_through_array?: () -> bool?
+      end
+    end
+  end
+end
+
+class ActiveRecord::Reflection::ThroughReflection
+  include Torque::PostgreSQL::Reflection::ThroughReflection
+end

data/sig/torque/postgresql/reflection.rbs

@@ -0,0 +1,11 @@
+module Torque
+  module PostgreSQL
+    module Reflection
+      def create: (Symbol macro, Symbol name, Proc? scope, Hash[Symbol, untyped] options, model ar) -> reflection?
+    end
+  end
+end
+
+module ActiveRecord::Reflection
+  extend Torque::PostgreSQL::Reflection
+end

data/sig/torque/postgresql/relation/auxiliary_statement.rbs

@@ -0,0 +1,29 @@
+module Torque
+  module PostgreSQL
+    module Relation
+      module AuxiliaryStatement
+        type statement = Symbol | singleton(PostgreSQL::AuxiliaryStatement)
+
+        def auxiliary_statements_values: () -> Array[PostgreSQL::AuxiliaryStatement]
+        def auxiliary_statements_values=: (Array[PostgreSQL::AuxiliaryStatement] value) -> Array[PostgreSQL::AuxiliaryStatement]
+        def with: (*statement args, ?recursive: bool, **untyped settings) -> relation
+        def with!: (*statement args, ?recursive: bool, **untyped settings) -> self
+        alias auxiliary_statements with
+        alias auxiliary_statements! with!
+        def bound_attributes: () -> Array[untyped]
+
+        private
+
+        def build_arel: (*untyped) -> ::Arel::SelectManager
+        def instantiate_auxiliary_statements: (*statement args, **untyped options) -> Array[PostgreSQL::AuxiliaryStatement]
+        def build_auxiliary_statements: (::Arel::SelectManager arel) -> Array[untyped]?
+        def auxiliary_statement_type: () -> (:recursive)?
+        def auxiliary_statement_error: (Symbol | String name) -> bot
+      end
+    end
+  end
+end
+
+class ActiveRecord::Relation
+  include Torque::PostgreSQL::Relation::AuxiliaryStatement
+end

data/sig/torque/postgresql/relation/buckets.rbs

@@ -0,0 +1,35 @@
+module Torque
+  module PostgreSQL
+    module Relation
+      module Buckets
+        type keys = Array[untyped] | ::Range[untyped]
+        type value = [arel_node, keys, Integer?, column_ref?, column_ref?]
+
+        def buckets_value: () -> value?
+        def buckets_value=: (value? value) -> value?
+        def buckets: (column_spec | arel_node attribute, keys values, ?count: Integer?, ?cast: column_ref?, ?as: column_ref?) -> relation
+        def buckets!: (column_spec | arel_node attribute, keys values, ?count: Integer?, ?cast: column_ref?, ?as: column_ref?) -> self
+        def calculate: (*untyped) -> untyped
+
+        module Initializer
+          def records: () -> (Array[record] | Hash[untyped, Array[record]])
+        end
+
+        private
+
+        def build_arel: (*untyped) -> ::Arel::SelectManager
+        def build_buckets_node: () -> ::Arel::Nodes::NamedFunction
+        def buckets_column: () -> String
+        def buckets_keys: () -> Array[untyped]
+      end
+
+      module Initializer
+        include Buckets::Initializer
+      end
+    end
+  end
+end
+
+class ActiveRecord::Relation
+  include Torque::PostgreSQL::Relation::Buckets
+end

data/sig/torque/postgresql/relation/cross_join.rbs

@@ -0,0 +1,63 @@
+module Torque
+  module PostgreSQL
+    module Relation
+      module CrossJoin
+        type row = Hash[column_ref, untyped] | Array[untyped]
+        type source = arel_node | relation | ::Arel::SelectManager | Array[row]
+        type ordinality = bool | column_ref
+
+        class Entry < ::Struct[untyped]
+          def node: () -> ::Arel::Nodes::Join
+          def node=: (::Arel::Nodes::Join value) -> ::Arel::Nodes::Join
+          def table: () -> arel_table
+          def table=: (arel_table value) -> arel_table
+        end
+
+        def self.build: (untyped source, column_ref as, Array[column_ref]? columns, Symbol | String mode, ordinality with_ordinality, ?Hash[column_ref, String?]? definitions) -> Entry
+
+        private
+
+        def self.columns_for: (untyped source, Array[column_ref]? columns) -> Array[column_ref]?
+        def self.ordinality_for: (ordinality value) -> column_ref?
+        def self.validate_ordinality!: (column_ref? ordinality, Array[column_ref]? columns, Hash[column_ref, String?]? definitions) -> nil
+        def self.source_for: (untyped source, Array[column_ref]? columns) -> [arel_node, bool]
+        def self.unnest_rows: (Array[row] rows, Array[column_ref]? columns) -> ::Arel::Nodes::NamedFunction
+        def self.row_values: (row row, Array[Symbol] keys) -> Array[untyped]
+        def self.join_for: (Symbol | String mode, Torque::PostgreSQL::Arel::Nodes::FromItem item) -> ::Arel::Nodes::Join
+
+        public
+
+        def cross_joins_value: () -> Hash[Symbol, Entry]
+        def cross_joins_value=: (Hash[Symbol, Entry] value) -> Hash[Symbol, Entry]
+        def cross_join: (untyped source, as: column_ref, ?columns: Array[column_ref]?, ?mode: Symbol | String, ?with_ordinality: ordinality) -> relation
+        def cross_join!: (untyped source, as: column_ref, ?columns: Array[column_ref]?, ?mode: Symbol | String, ?with_ordinality: ordinality) -> self
+
+        private
+
+        def build_arel: (*untyped) -> ::Arel::SelectManager
+
+        public
+
+        module Merger
+          def merge: () -> relation
+
+          private
+
+          def merge_cross_joins: () -> untyped
+        end
+      end
+    end
+  end
+end
+
+class ActiveRecord::Relation
+  include Torque::PostgreSQL::Relation::CrossJoin
+end
+
+class ActiveRecord::Relation::Merger
+  prepend Torque::PostgreSQL::Relation::CrossJoin::Merger
+end
+
+class ActiveRecord::Base
+  def self.cross_join: (untyped source, as: Torque::PostgreSQL::column_ref, ?columns: Array[Torque::PostgreSQL::column_ref]?, ?mode: Symbol | String, ?with_ordinality: Torque::PostgreSQL::Relation::CrossJoin::ordinality) -> ActiveRecord::Relation
+end

data/sig/torque/postgresql/relation/distinct_on.rbs

@@ -0,0 +1,16 @@
+module Torque
+  module PostgreSQL
+    module Relation
+      module DistinctOn
+        def distinct_on_values: () -> Array[column_spec]
+        def distinct_on_values=: (Array[column_spec] value) -> Array[column_spec]
+        def distinct_on: (*column_spec value) -> relation
+        def distinct_on!: (*column_spec value) -> self
+
+        private
+
+        def build_arel: (*untyped) -> ::Arel::SelectManager
+      end
+    end
+  end
+end