jsonapi-resources-anchor 2.12.0 → 2.13.1

data/lib/anchor/types.rb

@@ -7,23 +7,131 @@ module Anchor
     class Boolean; end
     class Null; end
     class Unknown; end
-    Record = Struct.new(:value_type)
-    Maybe = Struct.new(:type)
-    Array = Struct.new(:type)
-    Literal = Struct.new(:value)
-    Union = Struct.new(:types)
-    Intersection = Struct.new(:types)
-    Reference = Struct.new(:name) do
-      def anchor_schema_name
-        name
+    Identity = Data.define(:type)
+    Record = Data.define(:value_type)
+    Maybe = Data.define(:type)
+    Array = Data.define(:type)
+    Literal = Data.define(:value)
+    Union = Data.define(:types) do
+      def |(other)
+        self.class.new(types + [other])
       end
     end
-    Property = Struct.new(:name, :type, :optional, :description)
+    Intersection = Data.define(:types)
+    Reference = Data.define(:name) do
+      def anchor_schema_name = name
+
+      def |(other)
+        Anchor::Types::Union.new([self, other])
+      end
+    end
+
+    Property = Data.define(:name, :type, :optional, :description) do
+      def initialize(name:, type:, optional: false, description: nil)
+        super
+      end
+
+      def dup(name: nil, type: nil, optional: nil, description: nil)
+        self.class.new(
+          name: name || self.name,
+          type: type || self.type,
+          optional: optional.nil? ? self.optional : optional,
+          description: description || self.description,
+        )
+      end
+    end
+
     class Object
-      attr_reader :properties
+      attr_reader :properties, :properties_hash
+
+      delegate :[], :keys, :key?, to: :properties_hash
 
       def initialize(properties)
         @properties = properties || []
+        @properties_hash = properties.index_by(&:name) || []
+      end
+
+      def pick(keys)
+        picked = properties_hash.slice(*keys).values
+        self.class.new(picked)
+      end
+
+      def omit(keys)
+        omitted = properties_hash.except(*keys).values
+        self.class.new(omitted)
+      end
+
+      def pick_by_value(t)
+        props = properties.filter { |prop| prop.type.is_a?(t) }
+        self.class.new(props)
+      end
+
+      def untype(names = nil)
+        names ||= keys
+        pick(names).overwrite_values(Anchor::Types::Unknown) + omit(names)
+      end
+
+      def overwrite_values(type)
+        props = properties.map { |prop| prop.dup(type:) }
+        self.class.new(props)
+      end
+
+      def apply_higher(other, keep_description: :right)
+        props = properties.filter_map do |prop|
+          if (other_prop = other[prop.name])
+            desc = keep_description == :right ? other_prop.description : property.description
+            Property.new(prop.name, other_prop.type.new(prop.type), prop.optional, desc)
+          else
+            prop
+          end
+        end
+        self.class.new(props)
+      end
+
+      def overwrite(other, keep_description: :right)
+        props = properties.map do |prop|
+          if (other_prop = other[prop.name])
+            description = keep_description == :left ? prop.description : other_prop.description
+            other_prop.dup(description:)
+          else
+            prop.dup
+          end
+        end
+        self.class.new(props)
+      end
+
+      # left-based union
+      def +(other)
+        self.class.new(properties + other.omit(keys).properties)
+      end
+
+      def transform_keys
+        props = properties.map { |prop| prop.dup(name: yield(prop.name)) }
+        self.class.new(props)
+      end
+
+      def camelize
+        transform_keys { |name| Anchor::Types.camelize_without_inflection(name) }
+      end
+
+      def convert_case
+        transform_keys { |name| Anchor::Types.convert_case(name) }
+      end
+
+      def nonnullable
+        props = properties.map do |prop|
+          next prop unless prop.type.is_a?(Anchor::Types::Maybe)
+          prop.dup(type: prop.type.type)
+        end
+        self.class.new(props)
+      end
+
+      def nullable_to_optional
+        props = properties.map do |prop|
+          next prop unless prop.type.is_a?(Anchor::Types::Maybe)
+          prop.dup(type: prop.type.type, optional: true)
+        end
+        self.class.new(props)
       end
 
       class << self
@@ -35,6 +143,10 @@ module Anchor
           @properties ||= []
           @properties.push(Property.new(name, type, optional, description))
         end
+
+        def camelize
+          new(properties.map { |prop| prop.dup(name: Anchor::Types.camelize_without_inflection(prop.name)) })
+        end
       end
     end
 

data/lib/anchor/version.rb

@@ -1,3 +1,3 @@
 module Anchor
-  VERSION = "2.12.0"
+  VERSION = "2.13.1"
 end

data/lib/jsonapi-resources-anchor.rb

@@ -1,16 +1,15 @@
 require "anchor/types"
 require "anchor/anchor"
 require "anchor/config"
-require "anchor/resource"
 require "anchor/schema_generator"
 require "anchor/concerns/annotatable"
+require "anchor/concerns/typeable"
 require "anchor/concerns/custom_linkable"
 require "anchor/concerns/custom_meta"
 require "anchor/concerns/static_context"
 require "anchor/concerns/type_inferable"
 require "anchor/concerns/schema_serializable"
 require "anchor/schema"
-require "anchor/types/inference/jsonapi"
 require "anchor/types/inference/active_record"
 require "anchor/types/inference/rbs"
 require "anchor/type_script/file_structure"
@@ -23,3 +22,37 @@ require "anchor/type_script/resource"
 require "anchor/json_schema/serializer"
 require "anchor/json_schema/schema_generator"
 require "anchor/json_schema/resource"
+
+require "anchor/inference/active_record/types"
+require "anchor/inference/active_record/types/base"
+require "anchor/inference/active_record/types/column_comments"
+require "anchor/inference/active_record/types/presence_required"
+require "anchor/inference/active_record/types/serialized"
+require "anchor/inference/active_record/types/defaulted"
+require "anchor/inference/active_record/types/overridden"
+
+require "anchor/inference/active_record/infer"
+require "anchor/inference/active_record/infer/base"
+require "anchor/inference/active_record/infer/columns"
+require "anchor/inference/active_record/infer/model"
+require "anchor/inference/active_record/infer/enums"
+require "anchor/inference/active_record/infer/rbs"
+
+require "anchor/inference/jsonapi/types"
+require "anchor/inference/jsonapi/types/base"
+require "anchor/inference/jsonapi/types/active_record_relationships_wrapper"
+require "anchor/inference/jsonapi/types/relationships_wrapper"
+require "anchor/inference/jsonapi/types/empty"
+require "anchor/inference/jsonapi/types/overridden"
+require "anchor/inference/jsonapi/types/anchor_comments"
+require "anchor/inference/jsonapi/types/readable"
+
+require "anchor/inference/jsonapi/infer"
+require "anchor/inference/jsonapi/infer/base"
+require "anchor/inference/jsonapi/infer/anchor_def"
+require "anchor/inference/jsonapi/infer/shell"
+require "anchor/inference/jsonapi/infer/rbs"
+require "anchor/inference/jsonapi/infer/relationship_references"
+require "anchor/inference/jsonapi/infer/resource"
+
+require "anchor/inference/jsonapi/read_type"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jsonapi-resources-anchor
 version: !ruby/object:Gem::Version
-  version: 2.12.0
+  version: 2.13.1
 platform: ruby
 authors:
 - Matt
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-10-14 00:00:00.000000000 Z
+date: 2025-10-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jsonapi-resources
@@ -93,11 +93,40 @@ files:
 - lib/anchor/concerns/schema_serializable.rb
 - lib/anchor/concerns/static_context.rb
 - lib/anchor/concerns/type_inferable.rb
+- lib/anchor/concerns/typeable.rb
 - lib/anchor/config.rb
+- lib/anchor/inference/active_record/infer.rb
+- lib/anchor/inference/active_record/infer/base.rb
+- lib/anchor/inference/active_record/infer/columns.rb
+- lib/anchor/inference/active_record/infer/enums.rb
+- lib/anchor/inference/active_record/infer/model.rb
+- lib/anchor/inference/active_record/infer/rbs.rb
+- lib/anchor/inference/active_record/types.rb
+- lib/anchor/inference/active_record/types/base.rb
+- lib/anchor/inference/active_record/types/column_comments.rb
+- lib/anchor/inference/active_record/types/defaulted.rb
+- lib/anchor/inference/active_record/types/overridden.rb
+- lib/anchor/inference/active_record/types/presence_required.rb
+- lib/anchor/inference/active_record/types/serialized.rb
+- lib/anchor/inference/jsonapi/infer.rb
+- lib/anchor/inference/jsonapi/infer/anchor_def.rb
+- lib/anchor/inference/jsonapi/infer/base.rb
+- lib/anchor/inference/jsonapi/infer/rbs.rb
+- lib/anchor/inference/jsonapi/infer/relationship_references.rb
+- lib/anchor/inference/jsonapi/infer/resource.rb
+- lib/anchor/inference/jsonapi/infer/shell.rb
+- lib/anchor/inference/jsonapi/read_type.rb
+- lib/anchor/inference/jsonapi/types.rb
+- lib/anchor/inference/jsonapi/types/active_record_relationships_wrapper.rb
+- lib/anchor/inference/jsonapi/types/anchor_comments.rb
+- lib/anchor/inference/jsonapi/types/base.rb
+- lib/anchor/inference/jsonapi/types/empty.rb
+- lib/anchor/inference/jsonapi/types/overridden.rb
+- lib/anchor/inference/jsonapi/types/readable.rb
+- lib/anchor/inference/jsonapi/types/relationships_wrapper.rb
 - lib/anchor/json_schema/resource.rb
 - lib/anchor/json_schema/schema_generator.rb
 - lib/anchor/json_schema/serializer.rb
-- lib/anchor/resource.rb
 - lib/anchor/schema.rb
 - lib/anchor/schema_generator.rb
 - lib/anchor/type_script/file_structure.rb
@@ -109,7 +138,6 @@ files:
 - lib/anchor/type_script/types.rb
 - lib/anchor/types.rb
 - lib/anchor/types/inference/active_record.rb
-- lib/anchor/types/inference/jsonapi.rb
 - lib/anchor/types/inference/rbs.rb
 - lib/anchor/version.rb
 - lib/jsonapi-resources-anchor.rb

data/lib/anchor/resource.rb

@@ -1,213 +0,0 @@
-module Anchor
-  class Resource
-    delegate_missing_to :@resource_klass
-    attr_reader :resource_klass
-
-    # resource_klass#anchor_attributes, #anchor_relationships, #anchor_attributes_descriptions,
-    # #anchor_relationships_descriptions are optional methods from Anchor::Annotatable.
-    # @param [JSONAPI::Resource] Must include Anchor::TypeInferable
-    def initialize(resource_klass)
-      @resource_klass = resource_klass
-      @anchor_attributes = resource_klass.try(:anchor_attributes) || {}
-      @anchor_relationships = resource_klass.try(:anchor_relationships) || {}
-      @anchor_attributes_descriptions = resource_klass.try(:anchor_attributes_descriptions) || {}
-      @anchor_relationships_descriptions = resource_klass.try(:anchor_relationships_descriptions) || {}
-      @anchor_method_added_count = resource_klass.anchor_method_added_count || Hash.new(0)
-      @anchor_links_schema = resource_klass.try(:anchor_links_schema) || nil
-      @anchor_meta_schema = resource_klass.try(:anchor_meta_schema) || nil
-    end
-
-    def express(...)
-      raise NotImplementedError
-    end
-
-    private
-
-    delegate :convert_case, to: Anchor::Types
-
-    def schema_fetchable_fields(context:, include_all_fields:)
-      return fields unless statically_determinable_fetchable_fields? && !include_all_fields
-      @resource_klass.anchor_fetchable_fields(context)
-    end
-
-    def statically_determinable_fetchable_fields?
-      @resource_klass.singleton_class.method_defined?(:anchor_fetchable_fields)
-    end
-
-    # @return [Anchor::Types::Property]
-    def id_property
-      # TODO: resource_key_type can also return a proc
-      res_key_type = case resource_key_type
-      when :integer then Anchor::Types::Integer
-      else Anchor::Types::String
-      end
-
-      Anchor::Types::Property.new(:id, res_key_type)
-    end
-
-    # @return [Anchor::Types::Property]
-    def type_property
-      Anchor::Types::Property.new(:type, Anchor::Types::Literal.new(_type))
-    end
-
-    # @param included_fields [Array<Symbol>]
-    # @return [Array<Anchor::Types::Property>]
-    def anchor_attributes_properties(included_fields:)
-      _attributes.except(:id).filter_map do |attr, options|
-        next if included_fields.exclude?(attr.to_sym)
-        description = @anchor_attributes_descriptions[attr]
-        next Anchor::Types::Property.new(
-          convert_case(attr),
-          @anchor_attributes[attr],
-          false,
-          description,
-        ) if @anchor_attributes.key?(attr)
-
-        type = begin
-          model_method = options[:delegate] || attr
-          resource_method = attr
-
-          model_method_defined = _model_class.try(
-            :method_defined?,
-            model_method.to_sym,
-          ) && !_model_class.instance_method(model_method.to_sym)
-            .owner.is_a?(ActiveRecord::AttributeMethods::GeneratedAttributeMethods)
-          resource_method_defined = @anchor_method_added_count[resource_method.to_sym] > 1
-          serializer_defined = (_model_class.try(:attribute_types) || {})[model_method.to_s].respond_to?(:coder)
-          method_defined = model_method_defined || resource_method_defined || serializer_defined
-
-          enum = Anchor.config.infer_ar_enums && !method_defined && _model_class.try(:defined_enums).try(:[], model_method.to_s)
-          column = !method_defined && _model_class.try(:columns_hash).try(:[], model_method.to_s)
-
-          rbs_defined = defined?(::RBS) && ::RBS::VERSION.first == "3"
-
-          if resource_method_defined && rbs_defined
-            Anchor::Types::Inference::RBS.from(name.to_sym, resource_method)
-          elsif model_method_defined && rbs_defined
-            Anchor::Types::Inference::RBS.from(_model_class.name.to_sym, model_method.to_sym)
-          elsif column
-            type = Anchor::Types::Inference::ActiveRecord::SQL.from(column)
-
-            if enum
-              enum_type = Anchor::Types::Union.new(enum.map { |_key, val| Anchor::Types::Literal.new(val) })
-              type = type.is_a?(Anchor::Types::Maybe) ? Anchor::Types::Maybe.new(enum_type) : enum_type
-            end
-
-            unless description
-              description = column.comment if Anchor.config.use_active_record_comment
-              if description && !Anchor.config.ar_comment_to_string.nil?
-                description = Anchor.config.ar_comment_to_string.call(description)
-              end
-            end
-            check_presence = type.is_a?(Anchor::Types::Maybe) && Anchor.config.use_active_record_validations
-            if check_presence && _model_class.validators_on(model_method).any? do |v|
-                 if v.is_a?(ActiveRecord::Validations::NumericalityValidator)
-                   opts = v.options.with_indifferent_access
-                   !(opts[:allow_nil] || opts[:if] || opts[:unless] || opts[:on])
-                 elsif v.is_a?(ActiveRecord::Validations::PresenceValidator)
-                   opts = v.options.with_indifferent_access
-                   !(opts[:if] || opts[:unless] || opts[:on])
-                 end
-               end
-              type.type
-            elsif type.is_a?(Anchor::Types::Maybe) && Anchor.config.infer_default_as_non_null
-              column.default.present? || column.default_function.present? && column.instance_variable_get(:@generated).blank? ? type.type : type
-            else
-              type
-            end
-          elsif rbs_defined
-            # TODO: Methods may not be defined on the class at generation time?
-            [
-              Anchor::Types::Inference::RBS.from(name.to_sym, resource_method),
-              Anchor::Types::Inference::RBS.from(_model_class.name.to_sym, model_method.to_sym),
-            ].find { |t| t != Anchor::Types::Unknown } || Anchor::Types::Unknown
-          else
-            Anchor::Types::Unknown
-          end
-        end
-
-        Anchor::Types::Property.new(convert_case(attr), type, false, description)
-      end
-    end
-
-    # @param included_fields [Array<Symbol>]
-    # @return [Anchor::Types::Property, NilClass]
-    def anchor_relationships_property(included_fields:)
-      anchor_relationships_properties(included_fields:).then do |properties|
-        break if properties.blank?
-        Anchor::Types::Property.new(:relationships, Anchor::Types::Object.new(properties))
-      end
-    end
-
-    def anchor_links_property
-      if @anchor_links_schema
-        Anchor::Types::Property.new("links", @anchor_links_schema, false)
-      end
-    end
-
-    def anchor_meta_property
-      if @anchor_meta_schema
-        Anchor::Types::Property.new("meta", @anchor_meta_schema, false)
-      end
-    end
-
-    # @param included_fields [Array<Symbol>]
-    # @return [Array<Anchor::Types::Property>]
-    def anchor_relationships_properties(included_fields:)
-      _relationships.filter_map do |name, rel|
-        next if included_fields.exclude?(name.to_sym)
-        description = @anchor_relationships_descriptions[name]
-        relationship_type = relationship_type_for(rel, rel.resource_klass, name) if @anchor_relationships.exclude?(name)
-
-        relationship_type ||= begin
-          anchor_relationship = @anchor_relationships[name]
-
-          type = if (resources = anchor_relationship.resources)
-            references = resources.map do |resource_klass|
-              Anchor::Types::Reference.new(resource_klass.anchor_schema_name)
-            end
-            null_type = Array.wrap(anchor_relationship.null_elements.presence && Anchor::Types::Null)
-            Anchor::Types::Union.new(references + null_type)
-          else
-            Anchor::Types::Reference.new(anchor_relationship.resource.anchor_schema_name)
-          end
-
-          type = Anchor::Types::Inference::JSONAPI.wrapper_from_relationship(rel).call(type)
-          anchor_relationship.null.present? ? Anchor::Types::Maybe.new(type) : type
-        end
-
-        use_optional = Anchor.config.infer_nullable_relationships_as_optional
-        if use_optional && relationship_type.is_a?(Anchor::Types::Maybe)
-          Anchor::Types::Property.new(convert_case(name), relationship_type.type, true, description)
-        else
-          Anchor::Types::Property.new(convert_case(name), relationship_type, false, description)
-        end
-      end
-    end
-
-    # @param rel [Relationship]
-    # @param resource_klass [Anchor::Resource]
-    # @param name [String, Symbol]
-    # @return [Anchor::Types::Reference, Anchor::Types::Array<Anchor::Types::Reference>, Anchor::Types::Maybe<Anchor::Types::Reference>, Anchor::Types::Union<Anchor::Types::Reference>]
-    def relationship_type_for(rel, resource_klass, name)
-      rel_type = if rel.polymorphic? && rel.respond_to?(:polymorphic_types) # 0.11.0.beta2
-        resource_klasses = rel.polymorphic_types.map { |t| resource_klass_for(t) }
-        Anchor::Types::Union.new(resource_klasses.map { |rk| Anchor::Types::Reference.new(rk.anchor_schema_name) })
-      elsif rel.polymorphic? && rel.class.respond_to?(:polymorphic_types) # TODO: < 0.11.0.beta2
-        resource_klasses = rel.class.polymorphic_types.map { |t| resource_klass_for(t) }
-        Anchor::Types::Union.new(resource_klasses.map { |rk| Anchor::Types::Reference.new(rk.anchor_schema_name) })
-      end
-
-      rel_type ||= Anchor::Types::Reference.new(resource_klass.anchor_schema_name)
-      model_relationship_name = (rel.options[:relation_name] || name).to_s
-      reflection = _model_class.try(:reflections).try(:[], model_relationship_name)
-      wrapper = if reflection
-        Anchor::Types::Inference::ActiveRecord.wrapper_from_reflection(reflection)
-      else
-        Anchor::Types::Inference::JSONAPI.wrapper_from_relationship(rel)
-      end
-
-      wrapper.call(rel_type)
-    end
-  end
-end

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

@@ -1,14 +0,0 @@
-module Anchor::Types::Inference
-  module JSONAPI
-    class << self
-      # @return [Proc{Type => Type, Anchor::Types::Array<Type>}]
-      def wrapper_from_relationship(relationship)
-        case relationship
-        when ::JSONAPI::Relationship::ToOne then ->(type) { type }
-        when ::JSONAPI::Relationship::ToMany then ->(type) { Anchor::Types::Array.new(type) }
-        else raise "#{relationship.class.name} not supported"
-        end
-      end
-    end
-  end
-end