jsonapi-resources-anchor 2.12.0 → 2.13.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a315147926ca737e06a0b594d33a8a5d435333abfb529c2ae8fade5342a641e
-  data.tar.gz: 13fd9b832e61b49bec167c58b45700b5b527fee09d4eb555f4dc4a4680395078
+  metadata.gz: 4c509ff3d599c7750df7ed4be56c5ec1cc6b72d89e4e9c6b4c1575b342b14a4a
+  data.tar.gz: 3def582ca445df2805878e8b9ac378119f82fac569c4ef39835c5e279093918a
 SHA512:
-  metadata.gz: 48ad87a68af94a2774d734ac8b591e1e77f25f558706d0b9de4d95d81f136b7edbd5a161c62732d5c5f5e35e94bbf1352dfffc54ab44b2b3b4c7b6dbaf98e4cd
-  data.tar.gz: 4d0ed1301e0a22b61c867603b8484d7bcf7a925365caa7c90032981f19dab78e2487e3f239bfdd86bf71c75c9bc7cf9888bc62c8c42f27d6237053c64772af65
+  metadata.gz: 20f619334d556814e52f4e69352c8b0b2007810792e86324b0555ef8215ea0fe75f4cf3eb34a20103a9a5e02926f1433938ef1b6590226d946299867057b3ef5
+  data.tar.gz: f9f5f9ec6ab1c10d7974961669c2bb31199263fa4fb50f3f16b2d90c485ded025c3cd47604494636309af8c52d4e69bce6d0efb74d5ef4cfbdee45fe7eadac70

data/lib/anchor/concerns/typeable.rb

@@ -0,0 +1,26 @@
+module Anchor
+  module Typeable
+    extend ActiveSupport::Concern
+
+    included do
+      def object(...) = Anchor::Types::Object.new(...)
+      def property(...) = Anchor::Types::Property.new(...)
+      def maybe(...) = Anchor::Types::Maybe.new(...)
+      def array(...) = Anchor::Types::Array.new(...)
+      def union(...) = Anchor::Types::Union.new(...)
+      def literal(...) = Anchor::Types::Literal.new(...)
+      def literals(values) = union(values.map { |value| literal(value) })
+      def reference(...) = Anchor::Types::Reference.new(...)
+      def references(names) = union(names.map { |name| reference(name) })
+      def record(value_type = Anchor::Types::Unknown) = Anchor::Types::Record.new(value_type)
+
+      def boolean = Anchor::Types::Boolean
+      def null = Anchor::Types::Null
+      def unknown = Anchor::Types::Unknown
+      def string = Anchor::Types::String
+      def float = Anchor::Types::Float
+      def integer = Anchor::Types::Integer
+      def big_decimal = Anchor::Types::BigDecimal
+    end
+  end
+end

data/lib/anchor/config.rb

@@ -11,7 +11,9 @@ module Anchor
       :array_bracket_notation,
       :infer_default_as_non_null,
       :ar_comment_to_string,
-      :infer_ar_enums
+      :infer_ar_enums,
+      :rbs,
+      :rbs_sig_path
 
     def initialize
       @ar_column_to_type = nil
@@ -26,6 +28,8 @@ module Anchor
       @infer_default_as_non_null = nil
       @ar_comment_to_string = nil
       @infer_ar_enums = nil
+      @rbs = "off"
+      @rbs_sig_path = Rails.root.join("sig")
     end
   end
 end

data/lib/anchor/inference/active_record/infer/base.rb

@@ -0,0 +1,12 @@
+module Anchor::Inference::ActiveRecord::Infer
+  class Base
+    include Anchor::Typeable
+
+    def initialize(klass)
+      @klass = klass
+    end
+
+    def self.infer(...) = new(...).infer
+    def infer = raise NotImplementedError
+  end
+end

data/lib/anchor/inference/active_record/infer/columns.rb

@@ -0,0 +1,42 @@
+module Anchor::Inference::ActiveRecord::Infer
+  class Columns < Base
+    def infer = object(properties)
+
+    private
+
+    def properties
+      @klass.columns_hash.map do |name, column|
+        next property(name, Anchor.config.ar_column_to_type.call(column)) if Anchor.config.ar_column_to_type
+        metadata_type = from_sql_type_metadata(column.sql_type_metadata)
+        column_type = from_column_type(column.type)
+
+        type = [metadata_type, column_type, unknown].compact.first
+        type = column.null ? maybe(type) : type
+        property(name, type)
+      end
+    end
+
+    def from_sql_type_metadata(sql_type_metadata)
+      case sql_type_metadata.sql_type
+      when "character varying[]", "text[]" then array(string)
+      end
+    end
+
+    def from_column_type(type)
+      case type
+      when :boolean then boolean
+      when :date then string
+      when :datetime then string
+      when :decimal then big_decimal
+      when :float then float
+      when :integer then integer
+      when :json then record
+      when :jsonb then record
+      when :string then string
+      when :text then string
+      when :time then string
+      when :uuid then string
+      end
+    end
+  end
+end

data/lib/anchor/inference/active_record/infer/enums.rb

@@ -0,0 +1,17 @@
+module Anchor::Inference::ActiveRecord::Infer
+  class Enums < Base
+    def infer = object(properties)
+
+    private
+
+    def properties
+      @klass.columns_hash.slice(*defined_enums.keys).merge(defined_enums) do |name, column, enum|
+        property(name, column.null ? maybe(enum) : enum)
+      end.values
+    end
+
+    def defined_enums
+      @defined_enums ||= @klass.defined_enums.transform_values { |enum| literals(enum.values) }
+    end
+  end
+end

data/lib/anchor/inference/active_record/infer/model.rb

@@ -0,0 +1,64 @@
+# TODO: Is attribute_types.keys ⊅ columns_hash.keys possible?
+# def superset?(klass) = klass.attribute_types.keys.to_set.superset?(klass.columns_hash.keys.to_set)
+# !ActiveRecord::Base.descendants.reject(&:abstract_class?).all? { |k| superset?(k) }
+module Anchor::Inference::ActiveRecord::Infer
+  class Model < Base
+    module T
+      include Anchor::Inference::ActiveRecord::Types
+    end
+
+    def infer
+      res = [serialized, overridden, presence_required, defaulted, column_comments].compact.reduce(columns) do |acc, elem|
+        elem.wrap(acc)
+      end
+
+      res.overwrite(
+        rbs.pick(
+          res.pick_by_value(unknown.singleton_class).keys,
+        ),
+        keep_description: :left,
+      )
+    end
+
+    private
+
+    def columns
+      Columns.infer(@klass).overwrite(enums, keep_description: :left)
+    end
+
+    def enums
+      return object([]) unless Anchor.config.infer_ar_enums
+      @enum_types ||= Enums.infer(@klass)
+    end
+
+    def column_comments
+      return unless Anchor.config.use_active_record_comment
+      T::ColumnComments.new(@klass)
+    end
+
+    def rbs
+      return @rbs if defined?(@rbs)
+      return object([]) unless Anchor::Types::Inference::RBS.enabled?
+      Anchor::Types::Inference::RBS.validate!
+      @rbs = RBS.infer(@klass)
+    end
+
+    def serialized
+      T::Serialized.new(@klass)
+    end
+
+    def overridden
+      T::Overridden.new(@klass)
+    end
+
+    def presence_required
+      return unless Anchor.config.use_active_record_validations
+      T::PresenceRequired.new(@klass)
+    end
+
+    def defaulted
+      return unless Anchor.config.infer_default_as_non_null
+      T::Defaulted.new(@klass)
+    end
+  end
+end

data/lib/anchor/inference/active_record/infer/rbs.rb

@@ -0,0 +1,30 @@
+module Anchor::Inference::ActiveRecord::Infer
+  class RBS < Base
+    def infer = object(properties)
+
+    private
+
+    def properties
+      included_attributes.map do |method_name|
+        type = rbs.from_rbs_type(instance.methods[method_name].method_types.first.type.return_type)
+        Anchor::Types::Property.new(method_name.to_s, type)
+      end
+    end
+
+    def included_attributes
+      instance.methods.filter_map do |method_name, method_def|
+        next if method_def&.method_types&.length != 1
+        method_name
+      end
+    end
+
+    def instance
+      return @instance if defined?(@instance)
+      @instance ||= rbs.build_instance(@klass)
+    end
+
+    def rbs
+      @rbs ||= Anchor::Types::Inference::RBS
+    end
+  end
+end

data/lib/anchor/inference/active_record/infer.rb

@@ -0,0 +1,8 @@
+module Anchor
+  module Inference
+    module ActiveRecord
+      module Infer
+      end
+    end
+  end
+end

data/lib/anchor/inference/active_record/types/base.rb

@@ -0,0 +1,9 @@
+module Anchor::Inference::ActiveRecord::Types
+  class Base
+    def initialize(klass)
+      @klass = klass
+    end
+
+    def wrap(t) = raise NotImplementedError
+  end
+end

data/lib/anchor/inference/active_record/types/column_comments.rb

@@ -0,0 +1,29 @@
+module Anchor::Inference::ActiveRecord::Types
+  class ColumnComments < Base
+    include Anchor::Typeable
+
+    def wrap(t) = object(add_comments(t))
+
+    private
+
+    def add_comments(t)
+      t.properties.map do |prop|
+        prop.dup(description: comments[prop.name] || prop.description)
+      end
+    end
+
+    def comments
+      @comments ||= @klass.columns_hash.filter_map do |name, column|
+        next unless column.comment
+        description = serialize_comment(column.comment)
+        [name, description]
+      end.to_h
+    end
+
+    def serialize_comment(comment)
+      return comment unless Anchor.config.ar_comment_to_string
+
+      Anchor.config.ar_comment_to_string.call(comment)
+    end
+  end
+end

data/lib/anchor/inference/active_record/types/defaulted.rb

@@ -0,0 +1,17 @@
+module Anchor::Inference::ActiveRecord::Types
+  class Defaulted < Base
+    def wrap(t) = t.pick(names).nonnullable + t.omit(names)
+
+    private
+
+    def names
+      @klass.columns_hash.filter_map do |name, column|
+        name if has_default?(column)
+      end
+    end
+
+    def has_default?(column)
+      column.default.present? || column.default_function.present? && column.instance_variable_get(:@generated).blank?
+    end
+  end
+end

data/lib/anchor/inference/active_record/types/overridden.rb

@@ -0,0 +1,23 @@
+module Anchor::Inference::ActiveRecord::Types
+  class Overridden < Base
+    def wrap(t) = t.untype(names)
+
+    private
+
+    def names
+      @klass.attribute_types.keys.filter do |name|
+        next unless @klass.method_defined?(name.to_sym)
+        expected_generators.none? do |generator|
+          @klass.instance_method(name.to_sym).owner.is_a?(generator)
+        end
+      end
+    end
+
+    def expected_generators
+      @expected_generators ||= [
+        ActiveRecord::AttributeMethods::PrimaryKey,
+        ActiveRecord::AttributeMethods::GeneratedAttributeMethods,
+      ]
+    end
+  end
+end

data/lib/anchor/inference/active_record/types/presence_required.rb

@@ -0,0 +1,33 @@
+module Anchor::Inference::ActiveRecord::Types
+  class PresenceRequired < Base
+    def wrap(t) = t.pick(names).nonnullable + t.omit(names)
+
+    private
+
+    def names
+      @klass.attribute_types.keys.filter do |name|
+        presence_required_for?(name)
+      end
+    end
+
+    def presence_required_for?(attribute)
+      @klass.validators_on(attribute).any? do |validator|
+        case validator
+        when ActiveRecord::Validations::NumericalityValidator then numericality_presence_required?(validator)
+        when ActiveRecord::Validations::PresenceValidator then presence_required?(validator)
+        else false
+        end
+      end
+    end
+
+    def numericality_presence_required?(validator)
+      opts = validator.options.with_indifferent_access
+      !(opts[:allow_nil] || opts[:if] || opts[:unless] || opts[:on])
+    end
+
+    def presence_required?(validator)
+      opts = validator.options.with_indifferent_access
+      !(opts[:if] || opts[:unless] || opts[:on])
+    end
+  end
+end

data/lib/anchor/inference/active_record/types/serialized.rb

@@ -0,0 +1,13 @@
+module Anchor::Inference::ActiveRecord::Types
+  class Serialized < Base
+    def wrap(t) = t.untype(names)
+
+    private
+
+    def names
+      @klass.attribute_types.filter_map do |name, type|
+        name if type.respond_to?(:coder)
+      end
+    end
+  end
+end

data/lib/anchor/inference/active_record/types.rb

@@ -0,0 +1,8 @@
+module Anchor
+  module Inference
+    module ActiveRecord
+      module Types
+      end
+    end
+  end
+end

data/lib/anchor/inference/jsonapi/infer/anchor_def.rb

@@ -0,0 +1,86 @@
+module Anchor::Inference::JSONAPI::Infer
+  class AnchorDef < Base
+    delegate :resource_key_type, :_type, :_attributes, :_relationships, to: :@klass
+
+    def initialize(klass)
+      super(klass)
+      @anchor_attributes = klass.try(:anchor_attributes) || {}
+      @anchor_relationships = klass.try(:anchor_relationships) || {}
+      @anchor_attributes_descriptions = klass.try(:anchor_attributes_descriptions) || {}
+      @anchor_relationships_descriptions = klass.try(:anchor_relationships_descriptions) || {}
+      @anchor_links_schema = klass.try(:anchor_links_schema) || nil
+      @anchor_meta_schema = klass.try(:anchor_meta_schema) || nil
+    end
+
+    def infer
+      object([
+        id,
+        type,
+        *attributes,
+        *relationships,
+        meta,
+        links,
+      ].compact)
+    end
+
+    private
+
+    def attributes
+      _attributes.except(:id).filter_map do |attr, _|
+        next unless @anchor_attributes.key?(attr)
+
+        property(
+          attr.to_s,
+          @anchor_attributes[attr],
+          false,
+          @anchor_attributes_descriptions[attr],
+        )
+      end
+    end
+
+    def relationships
+      _relationships.filter_map do |name, rel|
+        next if @anchor_relationships.exclude?(name)
+
+        anchor_relationship = @anchor_relationships[name]
+        polymorphic = anchor_relationship.resources.present?
+
+        base_type = if polymorphic
+          references(anchor_relationship.resources.map(&:anchor_schema_name))
+        else
+          reference(anchor_relationship.resource.anchor_schema_name)
+        end
+
+        if rel.is_a?(::JSONAPI::Relationship::ToMany)
+          null_elements = anchor_relationship.null_elements.present?
+          base_type |= null if null_elements
+          base_type = array(base_type)
+        end
+
+        type = anchor_relationship.null.present? ? maybe(base_type) : base_type
+        property(name.to_s, type, false, @anchor_relationships_descriptions[name])
+      end
+    end
+
+    def id
+      # TODO: resource_key_type can also return a proc
+      res_key_type = case resource_key_type
+      when :integer then integer
+      else string
+      end
+      property("id", res_key_type)
+    end
+
+    def type = property("type", literal(_type))
+
+    def links
+      return unless @anchor_links_schema
+      property("links", @anchor_links_schema)
+    end
+
+    def meta
+      return unless @anchor_meta_schema
+      property("meta", @anchor_meta_schema)
+    end
+  end
+end

data/lib/anchor/inference/jsonapi/infer/base.rb

@@ -0,0 +1,12 @@
+module Anchor::Inference::JSONAPI::Infer
+  class Base
+    include Anchor::Typeable
+
+    def initialize(klass)
+      @klass = klass
+    end
+
+    def self.infer(...) = new(...).infer
+    def infer = raise NotImplementedError
+  end
+end

data/lib/anchor/inference/jsonapi/infer/rbs.rb

@@ -0,0 +1,30 @@
+module Anchor::Inference::JSONAPI::Infer
+  class RBS < Base
+    def infer = object(properties)
+
+    private
+
+    def properties
+      included_attributes.map do |method_name|
+        type = rbs.from_rbs_type(instance.methods[method_name].method_types.first.type.return_type)
+        Anchor::Types::Property.new(method_name.to_s, type)
+      end
+    end
+
+    def included_attributes
+      instance.methods.filter_map do |method_name, method_def|
+        next if method_def&.method_types&.length != 1
+        method_name
+      end
+    end
+
+    def instance
+      return @instance if defined?(@instance)
+      @instance ||= rbs.build_instance(@klass)
+    end
+
+    def rbs
+      @rbs ||= Anchor::Types::Inference::RBS
+    end
+  end
+end

data/lib/anchor/inference/jsonapi/infer/relationship_references.rb

@@ -0,0 +1,38 @@
+module Anchor::Inference::JSONAPI::Infer
+  class RelationshipReferences < Base
+    def infer = object(properties)
+
+    private
+
+    def properties
+      relationships.map { |name, rel| property(name.to_s, type_for(rel)) }
+    end
+
+    def type_for(rel)
+      begin
+        rel.resource_klass
+      rescue NameError => e
+        Rails.logger.warn(e.message)
+        return unknown
+      end
+
+      return reference(rel.resource_klass.anchor_schema_name) unless rel.polymorphic?
+
+      version = nil
+      version ||= rel.respond_to?(:polymorphic_types) && :new # 0.11.0.beta2
+      version ||= rel.class.respond_to?(:polymorphic_types) && :old # TODO: < 0.11.0.beta2
+
+      polymorphic_types = case version
+      when :new then rel.polymorphic_types
+      when :old then rel.class.polymorphic_types
+      end
+
+      return reference(rel.resource_klass.anchor_schema_name) unless polymorphic_types
+
+      resource_klasses = polymorphic_types.map { |t| @klass.resource_klass_for(t) }
+      union(resource_klasses.map { |rk| reference(rk.anchor_schema_name) })
+    end
+
+    def relationships = @klass._relationships
+  end
+end

data/lib/anchor/inference/jsonapi/infer/resource.rb

@@ -0,0 +1,72 @@
+module Anchor::Inference::JSONAPI::Infer
+  module T
+    include Anchor::Inference::JSONAPI::Types
+  end
+
+  class Resource < Base
+    def infer
+      shell = Shell.infer(@klass)
+      annotated = AnchorDef.infer(@klass)
+
+      model = delegated_attrs(attributes) + attributes + relationships
+      inferred = (model + shell).pick(shell.keys)
+
+      fallback = rbs.pick(inferred.pick_by_value(unknown.singleton_class).keys)
+      result = annotated + inferred.overwrite(fallback, keep_description: :left)
+
+      anchor_comments.wrap(result)
+    end
+
+    private
+
+    def attributes
+      @attributes ||= overridden.wrap(active_record_model)
+    end
+
+    def relationships
+      base_relationships = RelationshipReferences.infer(@klass)
+
+      jsonapi_relationships = relationships_wrapper.wrap(base_relationships)
+      active_record_relationships = active_record_relationships_wrapper.wrap(base_relationships)
+
+      active_record_relationships + jsonapi_relationships
+    end
+
+    def rbs
+      return @rbs if defined?(@rbs)
+      return object([]) unless Anchor::Types::Inference::RBS.enabled?
+      Anchor::Types::Inference::RBS.validate!
+      @rbs = RBS.infer(@klass)
+    end
+
+    def active_record_model
+      return object([]) unless @klass._model_class < ActiveRecord::Base
+      Anchor::Inference::ActiveRecord::Infer::Model.infer(@klass._model_class)
+    end
+
+    def active_record_relationships_wrapper
+      return T::Empty.new unless @klass._model_class < ActiveRecord::Base
+      T::ActiveRecordRelationshipsWrapper.new(@klass)
+    end
+
+    def relationships_wrapper
+      T::RelationshipsWrapper.new(@klass)
+    end
+
+    def overridden
+      T::Overridden.new(@klass)
+    end
+
+    def anchor_comments
+      T::AnchorComments.new(@klass)
+    end
+
+    def delegated_attrs(attrs)
+      props = @klass._attributes.filter_map do |name, opts|
+        next unless (delegate = opts[:delegate]&.to_s)
+        attrs[delegate]&.dup(name: name.to_s) || property(name.to_s, unknown)
+      end
+      object(props)
+    end
+  end
+end

data/lib/anchor/inference/jsonapi/infer/shell.rb

@@ -0,0 +1,24 @@
+module Anchor::Inference::JSONAPI::Infer
+  class Shell < Base
+    def infer
+      object({
+        id: unknown,
+        type: unknown,
+        **attributes.index_with { unknown },
+        **relationships.index_with { unknown },
+        meta: unknown,
+        links: unknown,
+      })
+    end
+
+    private
+
+    def object(hash)
+      props = hash.map { |key, type| property(key.to_s, type) }
+      Anchor::Types::Object.new(props)
+    end
+
+    def attributes = @klass._attributes.except(:id).keys
+    def relationships = @klass._relationships.keys
+  end
+end

data/lib/anchor/inference/jsonapi/infer.rb

@@ -0,0 +1,8 @@
+module Anchor
+  module Inference
+    module JSONAPI
+      module Infer
+      end
+    end
+  end
+end