jsonapi-resources-anchor 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 10487e8f527e3c65ae349ed70be50c6cfc7ef15791ec9e46197b4ffca184ac63
+  data.tar.gz: c66ceb8ee261a5230d580eda504010472a14dc6046054da32b5394b2fec223c4
+SHA512:
+  metadata.gz: 0d952dc77d9371b3bc8fc252680056c08442ed316509ad2f159dfd38312b7dd7b97481626769ba30e8c35aa8a08de762ad7061d8d6ba265258c591934ed6e02e
+  data.tar.gz: 2a427fa18bb7aa97fce4f45f78a276e5784e70e2222c33002f9069950b826231dbb6072c26381abf1f55c3a591e92a871f8f95f35a2be4b9e3d4c5f11a496249

data/lib/anchor/anchor.rb

@@ -0,0 +1,11 @@
+module Anchor
+  class << self
+    def config
+      @config ||= Anchor::Config.new
+    end
+
+    def configure
+      yield(config)
+    end
+  end
+end

data/lib/anchor/concerns/annotatable.rb

@@ -0,0 +1,40 @@
+module Anchor
+  module Annotatable
+    extend ActiveSupport::Concern
+
+    included do
+      class << self
+        attr_reader :anchor_attributes,
+          :anchor_relationships,
+          :anchor_attributes_descriptions,
+          :anchor_relationships_descriptions
+
+        # @param name [String, Symbol]
+        # @param annotation_or_options [Anchor::Types, Hash, NilClass]
+        # @param options [Hash]
+        def attribute(name, annotation_or_options = nil, options = {})
+          @anchor_attributes ||= {}
+          @anchor_attributes_descriptions ||= {}
+          opts = annotation_or_options.is_a?(Hash) ? annotation_or_options : options
+          annotation_given = !(annotation_or_options.is_a?(Hash) || annotation_or_options.nil?)
+          @anchor_attributes[name] = annotation_or_options if annotation_given
+          @anchor_attributes_descriptions[name] = opts[:description] if opts[:description]
+          super(name, opts)
+        end
+
+        # @param name [String, Symbol]
+        # @param annotation_or_options [Anchor::Types::Relationship, Hash, NilClass]
+        # @param options [Hash]
+        def relationship(name, annotation_or_options = nil, options = {})
+          @anchor_relationships ||= {}
+          @anchor_relationships_descriptions ||= {}
+          opts = annotation_or_options.is_a?(Hash) ? annotation_or_options : options
+          annotation_given = !(annotation_or_options.is_a?(Hash) || annotation_or_options.nil?)
+          @anchor_relationships[name] = annotation_or_options if annotation_given
+          @anchor_relationships_descriptions[name] = opts[:description] if opts[:description]
+          super(name, opts)
+        end
+      end
+    end
+  end
+end

data/lib/anchor/concerns/custom_linkable.rb

@@ -0,0 +1,14 @@
+module Anchor
+  module CustomLinkable
+    extend ActiveSupport::Concern
+
+    included do
+      class << self
+        # @param type [Anchor::Types]
+        def anchor_links_schema(type = nil)
+          @anchor_links_schema ||= type
+        end
+      end
+    end
+  end
+end

data/lib/anchor/concerns/custom_meta.rb

@@ -0,0 +1,14 @@
+module Anchor
+  module CustomMeta
+    extend ActiveSupport::Concern
+
+    included do
+      class << self
+        # @param type [Anchor::Types]
+        def anchor_meta_schema(type = nil)
+          @anchor_meta_schema ||= type
+        end
+      end
+    end
+  end
+end

data/lib/anchor/concerns/schema_serializable.rb

@@ -0,0 +1,10 @@
+module Anchor
+  module SchemaSerializable
+    extend ActiveSupport::Concern
+    include Anchor::TypeInferable
+    include Anchor::StaticContext
+    include Anchor::Annotatable
+    include Anchor::CustomLinkable
+    include Anchor::CustomMeta
+  end
+end

data/lib/anchor/concerns/static_context.rb

@@ -0,0 +1,13 @@
+module Anchor
+  module StaticContext
+    extend ActiveSupport::Concern
+
+    included do
+      class << self
+        def anchor_fetchable_fields(context)
+          fields
+        end
+      end
+    end
+  end
+end

data/lib/anchor/concerns/type_inferable.rb

@@ -0,0 +1,39 @@
+module Anchor
+  module TypeInferable
+    extend ActiveSupport::Concern
+
+    included do
+      class << self
+        attr_reader :anchor_method_added_count
+
+        # @param name [String] The type identifier to be used in the schema.
+        # @return [String]
+        def anchor_schema_name(name = nil)
+          @anchor_schema_name ||= name || anchor_default_schema_name
+        end
+
+        private
+
+        # @anchor_method_added_count[attribute] > 1 implies the attribute
+        # is computed via an instance method defined on the JSONAPI::Resource.
+        # `JSONAPI::Resource.attribute(:name, options)` adds #name to the resource.
+        # A user defined #name on the resource _also_ adds #name.
+        def method_added(method_name)
+          @anchor_method_added_count ||= Hash.new(0)
+          @anchor_method_added_count[method_name] += 1
+          super(method_name)
+        end
+
+        # inspiration from https://github.com/rmosolgo/graphql-ruby/blob/eda9b3d62b9e507787e590f0f179ec9d6956255a/lib/graphql/schema/member/base_dsl_methods.rb?plain=1#L102
+        def anchor_default_schema_name
+          # https://github.com/cerebris/jsonapi-resources/blob/d3c094b46a38650e583f40adc86474827b606fc7/lib/jsonapi/resource_common.rb?plain=1#L506
+          # https://github.com/cerebris/jsonapi-resources/blob/d3c094b46a38650e583f40adc86474827b606fc7/lib/jsonapi/resource_common.rb?plain=1#L564
+          return _type.to_s.classify if Anchor.config.use_type_as_schema_name
+
+          s_name = name.split("::").last
+          s_name.end_with?("Resource") ? s_name.sub(/Resource\Z/, "") : s_name
+        end
+      end
+    end
+  end
+end

data/lib/anchor/config.rb

@@ -0,0 +1,21 @@
+module Anchor
+  class Config
+    attr_accessor :ar_column_to_type,
+      :field_case,
+      :use_active_record_validations,
+      :use_active_record_comment,
+      :infer_nullable_relationships_as_optional,
+      :empty_relationship_type,
+      :use_type_as_schema_name
+
+    def initialize
+      @ar_column_to_type = nil
+      @field_case = nil
+      @use_active_record_validations = true
+      @use_active_record_comment = nil
+      @infer_nullable_relationships_as_optional = nil
+      @empty_relationship_type = nil
+      @use_type_as_schema_name = nil
+    end
+  end
+end

data/lib/anchor/json_schema/resource.rb

@@ -0,0 +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
+
+      properties = [id_property, type_property] +
+        Array.wrap(anchor_attributes_properties(included_fields:)) +
+        Array.wrap(anchor_relationships_property(included_fields:))
+
+      Anchor::Types::Object.new(properties)
+    end
+  end
+end

data/lib/anchor/json_schema/schema_generator.rb

@@ -0,0 +1,50 @@
+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
+      @register = register
+      @context = context
+      @include_all_fields = include_all_fields
+      @exclude_fields = exclude_fields
+    end
+
+    def call
+      result = {
+        "$schema" => "https://json-schema.org/draft-07/schema",
+        title: "Schema",
+      }
+      result.merge!(type_property(root_object))
+      result["$defs"] = definitions
+      result.to_json
+    end
+
+    private
+
+    def resources
+      @resources ||= @register.resources.map { |r| Anchor::JSONSchema::Resource.new(r) }
+    end
+
+    # @return [Anchor::Types::Object]
+    def root_object
+      properties = resources.map do |resource|
+        Types::Property.new(resource.anchor_schema_name.underscore, Types::Reference.new(resource.anchor_schema_name))
+      end
+
+      Types::Object.new(properties)
+    end
+
+    # @return [Hash{Symbol, String => Anchor::Types}]
+    def definitions
+      resources.map do |resource|
+        {
+          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)
+    end
+  end
+end

data/lib/anchor/json_schema/serializer.rb

@@ -0,0 +1,40 @@
+module Anchor::JSONSchema
+  class Serializer
+    class << self
+      def type_property(type)
+        case type
+        when Anchor::Types::String.singleton_class then { type: "string" }
+        when Anchor::Types::BigDecimal.singleton_class then { type: "string" }
+        when Anchor::Types::Float.singleton_class then { type: "number" }
+        when Anchor::Types::Integer.singleton_class then { type: "number" }
+        when Anchor::Types::Boolean.singleton_class then { type: "boolean" }
+        when Anchor::Types::Null.singleton_class then { type: "null" }
+        when Anchor::Types::Record, Anchor::Types::Record.singleton_class then {
+          type: "object",
+          additionalProperties: "true",
+        }
+        when Anchor::Types::Union then { oneOf: type.types.map { |type| type_property(type) } }
+        when Anchor::Types::Maybe then type_property(Anchor::Types::Union.new([type.type, Anchor::Types::Null]))
+        when Anchor::Types::Array then { type: "array", items: type_property(type.type) }
+        when Anchor::Types::Literal then { enum: [type.value] }
+        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::Unknown.singleton_class then {}
+        else raise RuntimeError
+        end
+      end
+
+      private
+
+      def serialize_object(type)
+        {
+          type: "object",
+          properties: type.properties.map { |p| { p.name => type_property(p.type) } }.reduce(&:merge),
+          required: type.properties.reject(&:optional).map(&:name),
+          additionalProperties: false,
+        }
+      end
+    end
+  end
+end

data/lib/anchor/resource.rb

@@ -0,0 +1,188 @@
+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
+
+          column = !method_defined && _model_class.try(:columns_hash).try(:[], model_method.to_s)
+          if column
+            type = Anchor::Types::Inference::ActiveRecord::SQL.from(column)
+            description ||= column.comment if Anchor.config.use_active_record_comment
+            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
+            else
+              type
+            end
+          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
+
+    # rubocop:disable Layout/LineLength
+    # @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
+  # rubocop:enable Layout/LineLength
+end

data/lib/anchor/schema.rb

@@ -0,0 +1,21 @@
+module Anchor
+  class Schema
+    class << self
+      Register = Struct.new(:resources, :enums, keyword_init: true)
+
+      def register
+        Register.new(resources: @resources || [], enums: @enums || [])
+      end
+
+      def resource(resource)
+        @resources ||= []
+        @resources.push(resource)
+      end
+
+      def enum(enum)
+        @enums ||= []
+        @enums.push(enum)
+      end
+    end
+  end
+end

data/lib/anchor/schema_generator.rb

@@ -0,0 +1,18 @@
+module Anchor
+  class SchemaGenerator
+    def initialize(register:, context:, include_all_fields:, exclude_fields:)
+      @register = register
+      @context = context
+      @include_all_fields = include_all_fields
+      @exclude_fields = exclude_fields
+    end
+
+    def self.call(...)
+      new(...).call
+    end
+
+    def call
+      raise NotImplementedError
+    end
+  end
+end

data/lib/anchor/type_script/file_structure.rb

@@ -0,0 +1,122 @@
+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)
+    class FileUtils
+      def self.imports_to_code(imports)
+        imports.group_by(&:file_name).map do |file_name, file_imports|
+          named_imports = file_imports.map do |import|
+            import.type.try(:anchor_schema_name) || import.type.name
+          end.join(",")
+
+          "import type { #{named_imports} } from \"./#{file_name[..-4]}\";"
+        end.join("\n") + "\n"
+      end
+
+      def self.def_to_code(identifier, object)
+        expression = Anchor::TypeScript::Serializer.type_string(object)
+        "type #{identifier} = #{expression};" + "\n"
+      end
+
+      def self.export_code(identifier)
+        "export { type #{identifier} };" + "\n"
+      end
+    end
+
+    def initialize(definition)
+      @definition = definition
+      @name = definition.name
+      @object = definition.object
+    end
+
+    def name
+      "#{@definition.name}.ts"
+    end
+
+    def to_code(manually_editable: false)
+      imports_string = FileUtils.imports_to_code(imports)
+      name = manually_editable ? "Model" : @name
+      typedef = FileUtils.def_to_code(name, @object)
+      export_string = FileUtils.export_code(@definition.name)
+
+      if manually_editable
+        start_autogen = "// START AUTOGEN\n"
+        end_autogen = "// END AUTOGEN\n"
+        unedited_export_def = "type #{@name} = Model;\n"
+        [start_autogen, imports_string, typedef, end_autogen, unedited_export_def, export_string].join("\n")
+      else
+        [imports_string, typedef, export_string].join("\n")
+      end
+    end
+
+    # @return [Array<Import>]
+    def imports
+      shared_imports + relationship_imports
+    end
+
+    private
+
+    # @return [Array<Import>]
+    def shared_imports
+      (utils_to_import + enums_to_import).map { |type| Import.new(file_name: "shared.ts", type:) }
+    end
+
+    # @return [Array<Import>]
+    def relationship_imports
+      relationships_to_import
+        .reject { |type| type.anchor_schema_name == @name }
+        .map { |type| Import.new(file_name: "#{type.anchor_schema_name}.ts", type:) }
+    end
+
+    def relationships_to_import
+      relationships = @object.properties.find { |p| p.name == :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::Union then type.types.flat_map { |t| references_from_type(t) }
+      when Anchor::Types::Reference then [type]
+      end.uniq.sort_by(&:anchor_schema_name)
+    end
+
+    def utils_to_import
+      maybe_type = has_maybe?(@object).presence && Anchor::Types::Reference.new("Maybe")
+      [maybe_type].compact
+    end
+
+    def has_maybe?(type)
+      case type
+      when Anchor::Types::Maybe then true
+      when Anchor::Types::Array then has_maybe?(type.type)
+      when Anchor::Types::Union then type.types.any? { |t| has_maybe?(t) }
+      when Anchor::Types::Object, Anchor::Types::Object.singleton_class then type.properties.any? do |p|
+        has_maybe?(p)
+      end
+      when Anchor::Types::Property then has_maybe?(type.type)
+      else false
+      end
+    end
+
+    def enums_to_import
+      enums_to_import_from_type(@object).uniq.sort_by(&:anchor_schema_name)
+    end
+
+    def enums_to_import_from_type(type)
+      case type
+      when Anchor::Types::Enum.singleton_class then [type]
+      when Anchor::Types::Array then enums_to_import_from_type(type.type)
+      when Anchor::Types::Maybe then enums_to_import_from_type(type.type)
+      when Anchor::Types::Union then type.types.flat_map { |t| enums_to_import_from_type(t) }
+      when Anchor::Types::Object, Anchor::Types::Object.singleton_class then type.properties.flat_map do |p|
+        enums_to_import_from_type(p)
+      end
+      when Anchor::Types::Property then enums_to_import_from_type(type.type)
+      else []
+      end
+    end
+  end
+end

data/lib/anchor/type_script/resource.rb

@@ -0,0 +1,33 @@
+module Anchor::TypeScript
+  class Resource < Anchor::Resource
+    Definition = Struct.new(:name, :object, keyword_init: true)
+
+    def express(...)
+      @object = object(...)
+      expression = Anchor::TypeScript::Serializer.type_string(@object)
+      "export type #{anchor_schema_name} = " + expression + ";"
+    end
+
+    def definition(...)
+      @object = object(...)
+      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
+
+      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
+
+      properties = [id_property, type_property] +
+        Array.wrap(anchor_attributes_properties(included_fields:)) +
+        Array.wrap(relationships_property) +
+        [anchor_meta_property].compact + [anchor_links_property].compact
+
+      Anchor::Types::Object.new(properties)
+    end
+  end
+end

data/lib/anchor/type_script/schema_generator.rb

@@ -0,0 +1,82 @@
+module Anchor::TypeScript
+  class SchemaGenerator < Anchor::SchemaGenerator
+    def initialize(register:, context: {}, include_all_fields: false, exclude_fields: nil) # rubocop:disable Lint/MissingSuper
+      @register = register
+      @context = context
+      @include_all_fields = include_all_fields
+      @exclude_fields = exclude_fields
+    end
+
+    def call
+      maybe_type = "type Maybe<T> = T | null;"
+
+      enum_expressions = enums.map(&:express)
+      type_expressions = resources.map do |r|
+        r.express(
+          context: @context,
+          include_all_fields: @include_all_fields,
+          exclude_fields: @exclude_fields.nil? ? [] : @exclude_fields[r.anchor_schema_name.to_sym],
+        )
+      end
+
+      ([maybe_type] + enum_expressions + type_expressions).join("\n\n") + "\n"
+    end
+
+    private
+
+    def resources
+      @resources ||= @register.resources.map { |r| Anchor::TypeScript::Resource.new(r) }
+    end
+
+    def enums
+      @enums ||= @register.enums.map { |e| Anchor::TypeScript::Types::Enum.new(e) }
+    end
+  end
+
+  class MultifileSchemaGenerator < Anchor::SchemaGenerator
+    def initialize(register:, context: {}, include_all_fields: false, exclude_fields: nil, manually_editable: true) # rubocop:disable Lint/MissingSuper
+      @register = register
+      @context = context
+      @include_all_fields = include_all_fields
+      @exclude_fields = exclude_fields
+      @manually_editable = manually_editable
+    end
+
+    def call
+      [shared_file] + resource_files
+    end
+
+    private
+
+    def shared_file
+      maybe_type = "export type Maybe<T> = T | null;"
+
+      enum_expressions = enums.map(&:express)
+      content = ([maybe_type] + enum_expressions).join("\n\n") + "\n"
+      { name: "shared.ts", content: }
+    end
+
+    def resource_files
+      resources.map do |r|
+        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)
+        content = file_structure.to_code(manually_editable: @manually_editable)
+        name = file_structure.name
+        { name:, content: }
+      end
+    end
+
+    def resources
+      @resources ||= @register.resources.map { |r| Anchor::TypeScript::Resource.new(r) }
+    end
+
+    def enums
+      @enums ||= @register.enums.map { |e| Anchor::TypeScript::Types::Enum.new(e) }
+    end
+  end
+end

data/lib/anchor/type_script/serializer.rb

@@ -0,0 +1,60 @@
+module Anchor::TypeScript
+  class Serializer
+    class << self
+      # rubocop:disable Layout/LineLength
+
+      def type_string(type, depth = 1)
+        case type
+        when Anchor::Types::String.singleton_class then "string"
+        when Anchor::Types::BigDecimal.singleton_class then "string"
+        when Anchor::Types::Float.singleton_class then "number"
+        when Anchor::Types::Integer.singleton_class then "number"
+        when Anchor::Types::Boolean.singleton_class then "boolean"
+        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::Maybe then "Maybe<#{type_string(type.type, depth)}>"
+        when Anchor::Types::Array then "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::Unknown.singleton_class then "unknown"
+        else raise RuntimeError
+        end
+      end
+      # rubocop:enable Layout/LineLength
+
+      private
+
+      def serialize_literal(value)
+        case value
+        when ::String, ::Symbol then "\"#{value}\""
+        else value.to_s
+        end
+      end
+
+      def serialize_object(type, depth)
+        return "{}" if type.properties.empty?
+        properties = type.properties.flat_map do |p|
+          [
+            p.description && "/** #{p.description} */",
+            "#{safe_name(p)}: #{type_string(p.type, depth + 1)};",
+          ].compact
+        end
+        indent = " " * (depth * 2)
+        properties = properties.map { |p| p.prepend(indent) }.join("\n")
+        ["{", properties, "}".prepend(indent[2..])].join("\n")
+      end
+
+      def safe_name(property)
+        name = property.name
+        if name.match?(/[^a-zA-Z0-9_]/)
+          "\"#{name}\""
+        else
+          name.to_s + (property.optional ? "?" : "")
+        end
+      end
+    end
+  end
+end

data/lib/anchor/type_script/types.rb

@@ -0,0 +1,24 @@
+module Anchor::TypeScript
+  module Types
+    class Enum
+      delegate_missing_to :@enum_klass
+
+      def initialize(enum_klass)
+        @enum_klass = enum_klass
+      end
+
+      # @return [String]
+      def express
+        ["export enum #{anchor_schema_name} {", named_constants, "}"].join("\n")
+      end
+
+      private
+
+      def named_constants
+        values.map do |name, value|
+          "  #{name.to_s.camelize} = #{Anchor::TypeScript::Serializer.type_string(value)},"
+        end.join("\n")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+module Anchor::Types::Inference
+  module ActiveRecord
+    class << self
+      # rubocop:disable Layout/LineLength
+
+      # @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
+      # rubocop:enable Layout/LineLength
+
+      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)
+
+          if ["character varying[]", "text[]"].include?(column.sql_type_metadata.sql_type)
+            type = Anchor::Types::Array.new(Anchor::Types::String)
+          end
+
+          column.null ? Anchor::Types::Maybe.new(type) : type
+        end
+
+        def default_ar_column_to_type(column)
+          from(column, check_config: false)
+        end
+
+        private
+
+        # 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)
+          case type
+          when :boolean then Anchor::Types::Boolean
+          when :date then Anchor::Types::String
+          when :datetime then Anchor::Types::String
+          when :decimal then Anchor::Types::BigDecimal
+          when :float then Anchor::Types::Float
+          when :integer then Anchor::Types::Integer
+          when :json then Anchor::Types::Record
+          when :jsonb then Anchor::Types::Record
+          when :string then Anchor::Types::String
+          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
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+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

data/lib/anchor/types.rb

@@ -0,0 +1,85 @@
+module Anchor
+  module Types
+    class String; end
+    class Float; end
+    class Integer; end
+    class BigDecimal; end
+    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)
+    Reference = Struct.new(:name) do
+      def anchor_schema_name
+        name
+      end
+    end
+    Property = Struct.new(:name, :type, :optional, :description)
+    class Object
+      attr_reader :properties
+
+      def initialize(properties)
+        @properties = properties || []
+      end
+
+      class << self
+        def properties
+          @properties ||= []
+        end
+
+        def property(name, type, optional: nil, description: nil)
+          @properties ||= []
+          @properties.push(Property.new(name, type, optional, description))
+        end
+      end
+    end
+
+    Relationship = Struct.new(:resource, :resources, :null, :null_elements, keyword_init: true)
+
+    class Enum
+      class << self
+        attr_reader :values
+
+        def anchor_schema_name(name = nil)
+          @anchor_schema_name ||= name || default_name
+        end
+
+        def value(name, value)
+          @values ||= []
+          @values.push([name, Types::Literal.new(value)])
+        end
+
+        private
+
+        def default_name
+          s_name = name.split("::").last
+          s_name.end_with?("Enum") ? s_name.sub(/Enum\Z/, "") : s_name
+        end
+      end
+    end
+
+    def self.camelize_without_inflection(val)
+      vals = val.split("_")
+      if vals.length == 1
+        vals[0]
+      else
+        ([vals[0]] + vals[1..].map(&:capitalize)).join("")
+      end
+    end
+
+    # @param value [String, Symbol]
+    # @return [String]
+    def self.convert_case(value)
+      case Anchor.config.field_case
+      when :camel then value.to_s.underscore.camelize(:lower)
+      when :camel_without_inflection then camelize_without_inflection(value.to_s.underscore)
+      when :kebab then value.to_s.underscore.dasherize
+      when :snake then value.to_s.underscore
+      else value
+      end
+    end
+  end
+end

data/lib/anchor/version.rb

@@ -0,0 +1,3 @@
+module Anchor
+  VERSION = "0.1.0"
+end

data/lib/jsonapi-resources-anchor.rb

@@ -0,0 +1,22 @@
+require "anchor/types"
+require "anchor/anchor"
+require "anchor/config"
+require "anchor/resource"
+require "anchor/schema_generator"
+require "anchor/concerns/annotatable"
+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/type_script/file_structure"
+require "anchor/type_script/types"
+require "anchor/type_script/schema_generator"
+require "anchor/type_script/serializer"
+require "anchor/type_script/resource"
+require "anchor/json_schema/serializer"
+require "anchor/json_schema/schema_generator"
+require "anchor/json_schema/resource"

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification
+name: jsonapi-resources-anchor
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Matt
+autorequire:
+bindir: bin
+cert_chain: []
+date: 1980-01-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: jsonapi-resources
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard-activesupport-concern
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description:
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/anchor/anchor.rb
+- lib/anchor/concerns/annotatable.rb
+- lib/anchor/concerns/custom_linkable.rb
+- lib/anchor/concerns/custom_meta.rb
+- lib/anchor/concerns/schema_serializable.rb
+- lib/anchor/concerns/static_context.rb
+- lib/anchor/concerns/type_inferable.rb
+- lib/anchor/config.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
+- lib/anchor/type_script/resource.rb
+- lib/anchor/type_script/schema_generator.rb
+- lib/anchor/type_script/serializer.rb
+- 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/version.rb
+- lib/jsonapi-resources-anchor.rb
+homepage:
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.11
+signing_key:
+specification_version: 4
+summary: jsonapi-resources type annotation, inference, and schema/docs generation
+test_files: []