jsonapi-resources-anchor 2.11.1 → 2.13.0

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

@@ -0,0 +1,47 @@
+module Anchor
+  module Inference
+    module JSONAPI
+      class ReadType
+        include Anchor::Typeable
+
+        attr_reader :t
+
+        delegate :convert_case, to: Anchor::Types
+
+        def initialize(klass, context: {}, include_all_fields: false)
+          @klass = klass
+          @t = Anchor::Inference::JSONAPI::Infer::Resource.infer(klass)
+          @context = context
+          @include_all_fields = include_all_fields
+        end
+
+        def self.infer(...) = new(...).infer
+
+        def infer
+          id +
+            type +
+            readable(attributes).convert_case +
+            object([property(
+              "relationships",
+              readable(relationships.nullable_to_optional).convert_case,
+            )]) +
+            meta +
+            links
+        end
+
+        def readable(t)
+          Anchor::Inference::JSONAPI::Types::Readable.new(
+            @klass, context: @context, include_all_fields: @include_all_fields
+          ).wrap(t)
+        end
+
+        def id = t.pick(["id"])
+        def type = t.pick(["type"])
+        def attributes = t.pick(@klass._attributes.except(:id).keys.map(&:to_s))
+        def relationships = t.pick(@klass._relationships.keys.map(&:to_s))
+        def meta = t["meta"].type.is_a?(unknown.singleton_class) ? t.pick([]) : t.pick(["meta"])
+        def links = t["links"].type.is_a?(unknown.singleton_class) ? t.pick([]) : t.pick(["links"])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module Anchor::Inference::JSONAPI::Types
+  class ActiveRecordRelationshipsWrapper < Base
+    include Anchor::Typeable
+
+    def initialize(klass)
+      super
+      @model_klass = klass._model_class
+    end
+
+    def wrap(t) = t.apply_higher(wrapper_type).pick(wrapper_type.keys)
+
+    private
+
+    def wrapper_type
+      return @wrapper_type if defined?(@wrapper_type)
+
+      props = @klass._relationships.filter_map do |name, rel|
+        relation_name = rel.options[:relation_name]&.to_s || name.to_s
+
+        next unless (ref = @model_klass.reflections[relation_name])
+
+        # TODO: comments from DB?
+        property(name.to_s, wrapper(ref), false, nil)
+      end
+
+      @wrapper_type = object(props)
+    end
+
+    def wrapper(reflection)
+      case reflection
+      when ::ActiveRecord::Reflection::BelongsToReflection then belongs_to_type(reflection)
+      when ::ActiveRecord::Reflection::HasOneReflection then Anchor::Types::Maybe
+      when ::ActiveRecord::Reflection::HasManyReflection then Anchor::Types::Array
+      when ::ActiveRecord::Reflection::HasAndBelongsToManyReflection then Anchor::Types::Array
+      when ::ActiveRecord::Reflection::ThroughReflection then wrapper(reflection.send(:delegate_reflection))
+      else raise "#{reflection.class.name} not supported" # TODO: make this unknown wrapper somehow ?
+      end
+    end
+
+    def belongs_to_type(reflection)
+      reflection.options[:optional] ? Anchor::Types::Maybe : Anchor::Types::Identity
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Anchor::Inference::JSONAPI::Types
+  class AnchorComments < Base
+    include Anchor::Typeable
+
+    def wrap(t) = object(properties(t))
+
+    private
+
+    def properties(t)
+      t.properties.map do |prop|
+        prop.dup(description: comments[prop.name] || prop.description)
+      end
+    end
+
+    def comments
+      return @comments if defined?(@comments)
+      attr_descs = @klass.try(:anchor_attributes_descriptions) || {}
+      rel_descs = @klass.try(:anchor_relationships_descriptions) || {}
+
+      @comments = attr_descs.merge(rel_descs).reject { |_, d| d.nil? }.transform_keys(&:to_s)
+    end
+  end
+end

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

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

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

@@ -0,0 +1,9 @@
+module Anchor::Inference::JSONAPI::Types
+  class Empty < Base
+    def initialize(klass = nil)
+      super(klass)
+    end
+
+    def wrap(t) = Anchor::Types::Object.new([])
+  end
+end

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

@@ -0,0 +1,14 @@
+module Anchor::Inference::JSONAPI::Types
+  class Overridden < Base
+    def wrap(t) = t.untype(names)
+
+    private
+
+    def names
+      count = @klass.anchor_method_added_count || Hash.new(0)
+      @klass._attributes.keys.filter_map do |name|
+        name.to_s if count[name.to_sym] > 1
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Anchor::Inference::JSONAPI::Types
+  class Readable < Base
+    def initialize(klass, context: {}, include_all_fields: false)
+      super(klass)
+      @context = context
+      @include_all_fields = include_all_fields
+    end
+
+    def wrap(t) = t.pick(names.map(&:to_s))
+
+    private
+
+    def names
+      return @klass.fields unless statically_determinable_fetchable_fields? && !@include_all_fields
+      @klass.anchor_fetchable_fields(@context)
+    end
+
+    def statically_determinable_fetchable_fields?
+      @klass.singleton_class.method_defined?(:anchor_fetchable_fields)
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Anchor::Inference::JSONAPI::Types
+  class RelationshipsWrapper < Base
+    include Anchor::Typeable
+
+    def wrap(t) = t.apply_higher(wrapper_type).pick(wrapper_type.keys)
+
+    private
+
+    def wrapper_type
+      return @wrapper_type if defined?(@wrapper_type)
+      props = @klass._relationships.map do |name, rel|
+        property(name.to_s, wrapper(rel), false, nil)
+      end
+      @wrapper_type = object(props)
+    end
+
+    def wrapper(relationship)
+      case relationship
+      when ::JSONAPI::Relationship::ToOne then Anchor::Types::Identity
+      when ::JSONAPI::Relationship::ToMany then Anchor::Types::Array
+      else raise "#{relationship.class.name} not supported"
+      end
+    end
+
+    def belongs_to_type(reflection)
+      reflection.options[:optional] ? Anchor::Types::Maybe : Anchor::Types::Identity
+    end
+  end
+end

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

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

data/lib/anchor/json_schema/resource.rb

@@ -1,14 +1,14 @@
 module Anchor::JSONSchema
-  class Resource < Anchor::Resource
-    def express(context: {}, include_all_fields:, exclude_fields:)
-      included_fields = schema_fetchable_fields(context:, include_all_fields:)
-      included_fields -= exclude_fields if exclude_fields
+  class Resource
+    delegate :anchor_schema_name, to: :@klass
 
-      properties = [id_property, type_property] +
-        Array.wrap(anchor_attributes_properties(included_fields:)) +
-        Array.wrap(anchor_relationships_property(included_fields:))
+    def initialize(klass)
+      @klass = klass
+    end
 
-      Anchor::Types::Object.new(properties)
+    def express(context: {}, include_all_fields:)
+      t = Anchor::Inference::JSONAPI::ReadType.infer(@klass, context:, include_all_fields:).omit(["meta", "links"])
+      t["relationships"].type.properties.count > 0 ? t : t.omit(["relationships"])
     end
   end
 end

data/lib/anchor/json_schema/schema_generator.rb

@@ -2,11 +2,10 @@ module Anchor::JSONSchema
   class SchemaGenerator < Anchor::SchemaGenerator
     delegate :type_property, to: Anchor::JSONSchema::Serializer
 
-    def initialize(register:, context: {}, include_all_fields: false, exclude_fields: nil) # rubocop:disable Lint/MissingSuper
+    def initialize(register:, context: {}, include_all_fields: false) # rubocop:disable Lint/MissingSuper
       @register = register
       @context = context
       @include_all_fields = include_all_fields
-      @exclude_fields = exclude_fields
     end
 
     def call
@@ -41,7 +40,6 @@ module Anchor::JSONSchema
           resource.anchor_schema_name => type_property(resource.express(
             context: @context,
             include_all_fields: @include_all_fields,
-            exclude_fields: @exclude_fields.nil? ? [] : @exclude_fields[r.anchor_schema_name.to_sym],
           )),
         }
       end.reduce(&:merge)

data/lib/anchor/json_schema/serializer.rb

@@ -20,7 +20,9 @@ module Anchor::JSONSchema
         when Anchor::Types::Reference then { "$ref" => "#/$defs/#{type.name}" }
         when Anchor::Types::Object, Anchor::Types::Object.singleton_class then serialize_object(type)
         when Anchor::Types::Enum.singleton_class then { enum: type.values.map(&:second) }
+        when Anchor::Types::Identity then type_property(type.type)
         when Anchor::Types::Unknown.singleton_class then {}
+        when Anchor::Types::Intersection then {}
         else raise RuntimeError
         end
       end

data/lib/anchor/schema.rb

@@ -3,7 +3,7 @@ module Anchor
     class DuplicateTypeError < StandardError; end
 
     class << self
-      Register = Struct.new(:resources, :enums, keyword_init: true)
+      Register = Data.define(:resources, :enums)
 
       def register
         Register.new(resources: @resources || [], enums: @enums || [])

data/lib/anchor/schema_generator.rb

@@ -1,10 +1,9 @@
 module Anchor
   class SchemaGenerator
-    def initialize(register:, context:, include_all_fields:, exclude_fields:)
+    def initialize(register:, context:, include_all_fields:)
       @register = register
       @context = context
       @include_all_fields = include_all_fields
-      @exclude_fields = exclude_fields
     end
 
     def self.call(...)

data/lib/anchor/type_script/file_structure.rb

@@ -2,7 +2,7 @@ module Anchor::TypeScript
   class FileStructure
     # @param file_name [String] name of file, e.g. model.ts
     # @param type [Anchor::Types]
-    Import = Struct.new(:file_name, :type, keyword_init: true)
+    Import = Data.define(:file_name, :type)
     class FileUtils
       def self.imports_to_code(imports)
         imports.group_by(&:file_name).map do |file_name, file_imports|
@@ -71,16 +71,17 @@ module Anchor::TypeScript
     end
 
     def relationships_to_import
-      relationships = @object.properties.find { |p| p.name == :relationships }
+      relationships = @object.properties.find { |p| p.name.to_sym == :relationships }
       return [] if relationships.nil? || relationships.type.try(:properties).nil?
       relationships.type.properties.flat_map { |p| references_from_type(p.type) }.uniq.sort_by(&:anchor_schema_name)
     end
 
     def references_from_type(type)
       case type
-      when Anchor::Types::Array, Anchor::Types::Maybe then references_from_type(type.type)
+      when Anchor::Types::Array, Anchor::Types::Maybe, Anchor::Types::Identity then references_from_type(type.type)
       when Anchor::Types::Union then type.types.flat_map { |t| references_from_type(t) }
       when Anchor::Types::Reference then [type]
+      when Anchor::Types::Unknown.singleton_class then []
       end.uniq.sort_by(&:anchor_schema_name)
     end
 

data/lib/anchor/type_script/multifile_schema_generator.rb

@@ -1,6 +1,6 @@
 module Anchor::TypeScript
   class MultifileSchemaGenerator < Anchor::SchemaGenerator
-    Result = Struct.new(:name, :text, :type, keyword_init: true)
+    Result = Data.define(:name, :text, :type)
 
     module FileType
       RESOURCE = "resource"
@@ -11,14 +11,12 @@ module Anchor::TypeScript
       register:,
       context: {},
       include_all_fields: false,
-      exclude_fields: nil,
       manually_editable: true,
       resource_file_extension: ".ts"
     )
       @register = register
       @context = context
       @include_all_fields = include_all_fields
-      @exclude_fields = exclude_fields
       @manually_editable = manually_editable
       @resource_file_extension = "." + resource_file_extension.sub(/^\./, "")
     end
@@ -47,7 +45,6 @@ module Anchor::TypeScript
         definition = r.definition(
           context: @context,
           include_all_fields: @include_all_fields,
-          exclude_fields: @exclude_fields.nil? ? [] : @exclude_fields[r.anchor_schema_name.to_sym],
         )
 
         file_structure = ::Anchor::TypeScript::FileStructure.new(definition, extension: @resource_file_extension)

data/lib/anchor/type_script/resource.rb

@@ -1,6 +1,12 @@
 module Anchor::TypeScript
-  class Resource < Anchor::Resource
-    Definition = Struct.new(:name, :object, keyword_init: true)
+  class Resource
+    Definition = Data.define(:name, :object)
+
+    delegate :anchor_schema_name, to: :@klass
+
+    def initialize(klass)
+      @klass = klass
+    end
 
     def express(...)
       @object = object(...)
@@ -13,21 +19,17 @@ module Anchor::TypeScript
       Definition.new(name: anchor_schema_name, object: @object)
     end
 
-    def object(context: {}, include_all_fields:, exclude_fields:)
-      included_fields = schema_fetchable_fields(context:, include_all_fields:)
-      included_fields -= exclude_fields if exclude_fields
+    def object(context: {}, include_all_fields:)
+      t = Anchor::Inference::JSONAPI::ReadType.infer(@klass, context:, include_all_fields:)
+      return t if t["relationships"].type.properties.count > 0
+      return t.omit(["relationships"]) unless Anchor.config.empty_relationship_type
 
-      relationships_property = anchor_relationships_property(included_fields:)
-      if relationships_property.nil? && Anchor.config.empty_relationship_type
-        relationships_property = Anchor::Types::Property.new(:relationships, Anchor.config.empty_relationship_type.call)
-      end
+      t.overwrite(Anchor::Types::Object.new([empty_relationships_property]))
+    end
 
-      properties = [id_property, type_property] +
-        Array.wrap(anchor_attributes_properties(included_fields:)) +
-        Array.wrap(relationships_property) +
-        [anchor_meta_property].compact + [anchor_links_property].compact
+    private
 
-      Anchor::Types::Object.new(properties)
-    end
+    def empty_relationships_property = property("relationships", Anchor.config.empty_relationship_type.call)
+    def property(...) = Anchor::Types::Property.new(...)
   end
 end

data/lib/anchor/type_script/schema_generator.rb

@@ -1,10 +1,9 @@
 module Anchor::TypeScript
   class SchemaGenerator < Anchor::SchemaGenerator
-    def initialize(register:, context: {}, include_all_fields: false, exclude_fields: nil) # rubocop:disable Lint/MissingSuper
+    def initialize(register:, context: {}, include_all_fields: false) # rubocop:disable Lint/MissingSuper
       @register = register
       @context = context
       @include_all_fields = include_all_fields
-      @exclude_fields = exclude_fields
     end
 
     def call
@@ -15,7 +14,6 @@ module Anchor::TypeScript
         r.express(
           context: @context,
           include_all_fields: @include_all_fields,
-          exclude_fields: @exclude_fields.nil? ? [] : @exclude_fields[r.anchor_schema_name.to_sym],
         )
       end
 

data/lib/anchor/type_script/serializer.rb

@@ -11,12 +11,14 @@ module Anchor::TypeScript
         when Anchor::Types::Null.singleton_class then "null"
         when Anchor::Types::Record, Anchor::Types::Record.singleton_class then "Record<string, #{type_string(type.try(:value_type) || Anchor::Types::Unknown)}>"
         when Anchor::Types::Union then type.types.map { |type| type_string(type, depth) }.join(" | ")
+        when Anchor::Types::Intersection then type.types.map { |type| "(#{type_string(type, depth)})" }.join(" & ")
         when Anchor::Types::Maybe then Anchor.config.maybe_as_union ? type_string(Anchor::Types::Union.new([type.type, Anchor::Types::Null]), depth) : "Maybe<#{type_string(type.type, depth)}>"
         when Anchor::Types::Array then Anchor.config.array_bracket_notation ? "(#{type_string(type.type, depth)})[]" : "Array<#{type_string(type.type, depth)}>"
         when Anchor::Types::Literal then serialize_literal(type.value)
         when Anchor::Types::Reference then type.name
         when Anchor::Types::Object, Anchor::Types::Object.singleton_class then serialize_object(type, depth)
         when Anchor::Types::Enum.singleton_class then type.anchor_schema_name
+        when Anchor::Types::Identity then type_string(type.type)
         when Anchor::Types::Unknown.singleton_class then "unknown"
         else raise RuntimeError
         end

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

@@ -1,49 +1,26 @@
 module Anchor::Types::Inference
   module ActiveRecord
-    class << self
-      # @return [Proc{Type => Type, Anchor::Types::Maybe<Type>, Anchor::Types::Array<Type>}]
-      def wrapper_from_reflection(reflection)
-        case reflection
-        when ::ActiveRecord::Reflection::BelongsToReflection then ->(type) { belongs_to_type(reflection, type) }
-        when ::ActiveRecord::Reflection::HasOneReflection then ->(type) { Anchor::Types::Maybe.new(type) }
-        when ::ActiveRecord::Reflection::HasManyReflection then ->(type) { Anchor::Types::Array.new(type) }
-        when ::ActiveRecord::Reflection::HasAndBelongsToManyReflection then ->(type) { Anchor::Types::Array.new(type) }
-        when ::ActiveRecord::Reflection::ThroughReflection then wrapper_from_reflection(reflection.send(:delegate_reflection))
-        else raise "#{reflection.class.name} not supported"
-        end
-      end
-
-      private
-
-      # @param reflection [::ActiveRecord::Reflection::BelongsToReflection]
-      # @param type [Anchor::Types]
-      # @return [Anchor::Types::Maybe<Type>, Type]
-      def belongs_to_type(reflection, type)
-        reflection.options[:optional] ? Anchor::Types::Maybe.new(type) : type
-      end
-    end
-
     module SQL
       class << self
-        def from(column, check_config: true)
-          return Anchor.config.ar_column_to_type.call(column) if check_config && Anchor.config.ar_column_to_type
-          type = from_sql_type(column.type)
+        def default_ar_column_to_type(column)
+          metadata_type = from_sql_type_metadata(column.sql_type_metadata)
+          column_type = from_column_type(column.type)
 
-          if ["character varying[]", "text[]"].include?(column.sql_type_metadata.sql_type)
-            type = Anchor::Types::Array.new(Anchor::Types::String)
-          end
+          type = [metadata_type, column_type, Anchor::Types::Unknown].compact.first
 
           column.null ? Anchor::Types::Maybe.new(type) : type
         end
 
-        def default_ar_column_to_type(column)
-          from(column, check_config: false)
-        end
-
         private
 
+        def from_sql_type_metadata(sql_type_metadata)
+          case sql_type_metadata.sql_type
+          when "character varying[]", "text[]" then Anchor::Types::Array.new(Anchor::Types::String)
+          end
+        end
+
         # inspiration from https://github.com/ElMassimo/types_from_serializers/blob/146ba40bc1a0da37473cd3b705a8ca982c2d173f/types_from_serializers/lib/types_from_serializers/generator.rb#L382
-        def from_sql_type(type)
+        def from_column_type(type)
           case type
           when :boolean then Anchor::Types::Boolean
           when :date then Anchor::Types::String
@@ -57,7 +34,6 @@ module Anchor::Types::Inference
           when :text then Anchor::Types::String
           when :time then Anchor::Types::String
           when :uuid then Anchor::Types::String
-          else Anchor::Types::Unknown
           end
         end
       end

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

@@ -0,0 +1,95 @@
+module Anchor::Types::Inference
+  module RBS
+    class << self
+      def enabled?
+        Anchor.config.rbs.to_s == "fallback"
+      end
+
+      def validate!
+        return if defined?(::RBS) && ::RBS::VERSION.first == "3"
+        raise "RBS version conflict: rbs ~> 3 required."
+      end
+
+      # @param klass [Class]
+      # @return [Class, nil]
+      def get_definition(klass)
+        env.class_decls.keys.find do |definition|
+          # TODO: Do we need both absolute and relative here?
+          [klass.name, "::#{klass.name}"].include?(definition.to_s)
+        end
+      end
+
+      def build_instance(klass)
+        if (definition = get_definition(klass))
+          builder.build_instance(definition)
+        end
+      end
+
+      def from_rbs_type(type)
+        case type
+        when ::RBS::Types::ClassInstance then from_class_instance(type)
+        when ::RBS::Types::Literal then Types::Literal.new(type.literal)
+        when ::RBS::Types::Bases::Bool then Types::Boolean
+        when ::RBS::Types::Bases::Nil then Types::Null
+        when ::RBS::Types::Bases::Void then Types::Unknown
+        when ::RBS::Types::Bases::Any then Types::Unknown
+        when ::RBS::Types::Optional then Types::Maybe.new(from_rbs_type(type.type))
+        when ::RBS::Types::Record then from_record(type)
+        when ::RBS::Types::Union then from_union(type)
+        when ::RBS::Types::Intersection then from_intersection(type)
+        when ::RBS::Types::Tuple then Types::Unknown # TODO
+        else Types::Unknown
+        end
+      end
+
+      private
+
+      def builder
+        @builder ||= ::RBS::DefinitionBuilder.new(env:)
+      end
+
+      def env
+        @env ||= ::RBS::Environment.from_loader(loader).resolve_type_names
+      end
+
+      def loader
+        @loader ||= ::RBS::EnvironmentLoader.new.tap do |l|
+          l.add(path: Anchor.config.rbs_sig_path)
+        end
+      end
+
+      def from_record(type)
+        properties = type.fields.map do |name, type|
+          Types::Property.new(name, from_rbs_type(type))
+        end
+        optional_properties = type.optional_fields.map do |name, type|
+          Types::Property.new(name, from_rbs_type(type), true)
+        end
+        Types::Object.new(properties + optional_properties)
+      end
+
+      def from_union(type)
+        types = type.types.map { |type| from_rbs_type(type) }
+        Types::Union.new(types)
+      end
+
+      def from_intersection(type)
+        types = type.types.map { |type| from_rbs_type(type) }
+        Types::Intersection.new(types)
+      end
+
+      def from_class_instance(type)
+        case type.name.to_s
+        when "::String" then Types::String
+        when "::Numeric" then Types::Float
+        when "::Integer" then Types::Integer
+        when "::Float" then Types::Float
+        when "::BigDecimal" then Types::String
+        when "::Boolean" then Types::Boolean
+        when "::Array" then Types::Array.new(from_rbs_type(type.args.first))
+        else Types::Unknown
+        end
+      end
+    end
+  end
+end