apiwork 0.0.0.pre → 0.1.1

data/lib/apiwork/adapter/standard/capability/sorting/operation.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Apiwork
+  module Adapter
+    class Standard
+      module Capability
+        class Sorting
+          class Operation < Adapter::Capability::Operation::Base
+            target :collection
+
+            def apply
+              params = request.query[:sort]
+              return if params.blank?
+
+              result(**Sort.apply(data, representation_class, params))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/apiwork/adapter/standard/capability/sorting.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Apiwork
+  module Adapter
+    class Standard
+      module Capability
+        class Sorting < Adapter::Capability::Base
+          capability_name :sorting
+
+          api_builder APIBuilder
+          contract_builder ContractBuilder
+          operation Operation
+        end
+      end
+    end
+  end
+end

data/lib/apiwork/adapter/standard/capability/writing/constants.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Apiwork
+  module Adapter
+    class Standard
+      module Capability
+        class Writing < Adapter::Capability::Base
+          module Constants
+            OP = :OP
+          end
+        end
+      end
+    end
+  end
+end

data/lib/apiwork/adapter/standard/capability/writing/contract_builder.rb

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+
+module Apiwork
+  module Adapter
+    class Standard
+      module Capability
+        class Writing
+          class ContractBuilder < Adapter::Capability::Contract::Base
+            def build
+              build_enums
+              build_payload_types
+              build_nested_payload_union if api_class.representation_registry.nested_writable?(representation_class)
+
+              %i[create update].each do |action_name|
+                next unless scope.action?(action_name)
+
+                payload_type_name = [action_name, 'payload'].join('_').to_sym
+                next unless type?(payload_type_name)
+
+                contract_action = action(action_name)
+                next if contract_action.resets_request?
+
+                contract_action.request do |request|
+                  request.body do |body|
+                    body.reference(representation_class.root_key.singular.to_sym, to: payload_type_name)
+                  end
+                end
+              end
+            end
+
+            private
+
+            def build_enums
+              representation_class.attributes.each do |name, attribute|
+                next unless attribute.enum&.any?
+
+                enum(name, values: attribute.enum)
+              end
+            end
+
+            def build_payload_types
+              build_payload_type(:create)
+              build_payload_type(:update)
+            end
+
+            def build_payload_type(action_name)
+              if sti_base_representation?
+                build_sti_payload_union(action_name)
+              else
+                build_standard_payload(action_name)
+              end
+            end
+
+            def build_standard_payload(action_name)
+              type_name = [action_name, 'payload'].join('_').to_sym
+              return if type?(type_name)
+
+              object(type_name, description: representation_class.description) do |object|
+                if representation_class.subclass?
+                  parent_inheritance = representation_class.superclass.inheritance
+
+                  object.literal(
+                    parent_inheritance.column,
+                    optional: action_name == :update,
+                    value: representation_class.sti_name,
+                  )
+                end
+
+                collect_writable_params(action_name).each do |param_config|
+                  object.param(param_config[:name], **param_config[:options])
+                end
+              end
+            end
+
+            def build_nested_payload_union
+              build_nested_payload(:create)
+              build_nested_payload(:update)
+              build_nested_payload(:delete)
+              build_nested_union
+            end
+
+            def build_nested_payload(action_name)
+              type_name = [:nested, action_name, :payload].join('_').to_sym
+              return if type?(type_name)
+
+              writable = action_name != :delete
+
+              object(type_name) do |object|
+                object.literal(Constants::OP, optional: true, value: action_name.to_s)
+                object.param(:id, optional: action_name != :delete, type: primary_key_type) unless action_name == :create
+
+                next unless writable
+
+                collect_writable_params(action_name).each do |param_config|
+                  object.param(param_config[:name], **param_config[:options])
+                end
+              end
+            end
+
+            def build_nested_union
+              return if type?(:nested_payload)
+
+              union(:nested_payload, discriminator: Constants::OP) do |union|
+                union.variant(tag: 'create') do |element|
+                  element.reference(scoped_type_name(:nested_create_payload))
+                end
+                union.variant(tag: 'update') do |element|
+                  element.reference(scoped_type_name(:nested_update_payload))
+                end
+                union.variant(tag: 'delete') do |element|
+                  element.reference(scoped_type_name(:nested_delete_payload))
+                end
+              end
+            end
+
+            def build_sti_payload_union(action_name)
+              representation_inheritance = representation_class.inheritance
+
+              variant_refs = representation_inheritance.subclasses.filter_map do |subclass|
+                subclass_contract = contract_for(subclass)
+                next unless subclass_contract
+
+                alias_name = subclass.root_key.singular.to_sym
+                import(subclass_contract, as: alias_name)
+
+                { tag: subclass.sti_name, type: [alias_name, action_name, 'payload'].join('_').to_sym }
+              end
+
+              union([action_name, 'payload'].join('_').to_sym, discriminator: representation_inheritance.column) do |union|
+                variant_refs.each do |variant_ref|
+                  union.variant(tag: variant_ref[:tag]) do |element|
+                    element.reference(variant_ref[:type])
+                  end
+                end
+              end
+            end
+
+            def collect_writable_params(action_name)
+              params = []
+
+              representation_class.attributes.each do |name, attribute|
+                next unless attribute.writable_for?(action_name)
+
+                params << { name:, options: attribute_options(attribute, action_name) }
+              end
+
+              representation_class.associations.each do |name, association|
+                next unless association.writable_for?(action_name)
+
+                params << { name:, options: association_options(association) }
+              end
+
+              params
+            end
+
+            def attribute_options(attribute, action_name)
+              options = {
+                deprecated: attribute.deprecated?,
+                description: attribute.description,
+                example: attribute.example,
+                format: attribute.format,
+                nullable: attribute.nullable?,
+                optional: action_name == :update || attribute.optional?,
+                type: attribute.type,
+              }
+
+              options[:min] = attribute.min if attribute.min
+              options[:max] = attribute.max if attribute.max
+              options[:of] = attribute.of if attribute.of
+              options[:enum] = attribute.name if attribute.enum
+
+              if attribute.element
+                element = attribute.element
+
+                if element.type == :array
+                  options[:of] = element.inner
+                else
+                  options[:shape] = element.shape
+                  options[:discriminator] = element.discriminator if element.discriminator
+                end
+              end
+
+              polymorphic_options = polymorphic_type_options(attribute)
+              options.merge!(polymorphic_options) if polymorphic_options
+
+              options
+            end
+
+            def polymorphic_type_options(attribute)
+              association = representation_class.polymorphic_association_for_type_column(attribute.name)
+              return nil unless association
+
+              allowed_values = association.polymorphic.map(&:polymorphic_name)
+
+              { enum: allowed_values }
+            end
+
+            def association_options(association)
+              payload_type = resolve_association_payload_type(association)
+
+              options = {
+                as: [association.name, 'attributes'].join('_').to_sym,
+                deprecated: association.deprecated?,
+                description: association.description,
+                example: association.example,
+                nullable: association.nullable?,
+                optional: true,
+              }
+
+              if payload_type
+                if association.collection?
+                  options[:type] = :array
+                  options[:of] = payload_type
+                else
+                  options[:type] = payload_type
+                end
+              else
+                options[:type] = association.collection? ? :array : :object
+              end
+
+              options
+            end
+
+            def resolve_association_payload_type(association)
+              return nil if association.polymorphic?
+
+              representation_class = association.representation_class
+              return nil unless representation_class
+
+              association_contract = contract_for(representation_class)
+              return nil unless association_contract
+
+              alias_name = representation_class.root_key.singular.to_sym
+              import(association_contract, as: alias_name)
+
+              [alias_name, 'nested_payload'].join('_').to_sym
+            end
+
+            def sti_base_representation?
+              inheritance = representation_class.inheritance
+              inheritance&.subclasses&.any? && inheritance.base_class == representation_class
+            end
+
+            def primary_key_type
+              model = representation_class.model_class
+              model.type_for_attribute(model.primary_key).type
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/apiwork/adapter/standard/capability/writing/operation/issue_mapper.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+module Apiwork
+  module Adapter
+    class Standard
+      module Capability
+        class Writing
+          class Operation
+            class IssueMapper
+              CODE_MAP = {
+                accepted: :accepted,
+                blank: :required,
+                confirmation: :confirmed,
+                empty: :required,
+                equal_to: :eq,
+                even: :even,
+                exclusion: :not_in,
+                greater_than: :gt,
+                greater_than_or_equal_to: :gte,
+                in: :in,
+                inclusion: :in,
+                invalid: :invalid,
+                less_than: :lt,
+                less_than_or_equal_to: :lte,
+                not_a_number: :number,
+                not_an_integer: :integer,
+                odd: :odd,
+                other_than: :ne,
+                present: :forbidden,
+                restrict_dependent_destroy: :associated,
+                taken: :unique,
+                too_long: :max,
+                too_short: :min,
+                wrong_length: :length,
+              }.freeze
+
+              DETAIL_MAP = {
+                accepted: 'Must be accepted',
+                associated: 'Invalid',
+                confirmed: 'Does not match',
+                eq: 'Wrong value',
+                even: 'Must be even',
+                forbidden: 'Must be blank',
+                format: 'Invalid format',
+                gt: 'Too small',
+                gte: 'Too small',
+                in: 'Invalid value',
+                integer: 'Not an integer',
+                invalid: 'Invalid',
+                length: 'Wrong length',
+                lt: 'Too large',
+                lte: 'Too large',
+                max: 'Too long',
+                min: 'Too short',
+                ne: 'Reserved value',
+                not_in: 'Reserved value',
+                number: 'Not a number',
+                odd: 'Must be odd',
+                required: 'Required',
+                unique: 'Already taken',
+              }.freeze
+
+              META_CODES = %i[min max length gt gte lt lte eq ne in].freeze
+
+              class << self
+                def map(record, translator, root_path: [])
+                  new(record, root_path, translator).map
+                end
+              end
+
+              def initialize(record, root_path, translator)
+                @record = record
+                @root_path = Array(root_path)
+                @translator = translator
+              end
+
+              def map
+                return [] unless @record.respond_to?(:errors)
+                return [] unless @record.errors.any?
+
+                attribute_issues + association_issues
+              end
+
+              private
+
+              def attribute_issues
+                @record.errors.filter_map do |error|
+                  next if nested_attribute_error?(error)
+
+                  build_issue(error)
+                end
+              end
+
+              def association_issues
+                collect_association_issues(:has_many) + collect_association_issues(:has_one)
+              end
+
+              def collect_association_issues(association_type)
+                result = []
+
+                @record.class.reflect_on_all_associations(association_type).each do |association|
+                  associated = @record.send(association.name)
+                  next unless associated
+
+                  items = association_type == :has_many ? associated : [associated]
+                  next unless items.respond_to?(:each)
+
+                  items.each_with_index do |item, index|
+                    next unless item.respond_to?(:errors)
+                    next unless item.errors.any?
+
+                    nested_path = build_association_path(association.name, index, association_type)
+                    result.concat(self.class.map(item, @translator, root_path: nested_path))
+                  end
+                end
+
+                result
+              end
+
+              def build_association_path(name, index, type)
+                if type == :has_many
+                  @root_path + [name, index]
+                else
+                  @root_path + [name]
+                end
+              end
+
+              def nested_attribute_error?(error)
+                error.attribute.to_s.include?('.')
+              end
+
+              def build_issue(error)
+                code = normalize_code(error)
+                attribute = resolve_attribute(error.attribute)
+                path = attribute == :base ? @root_path : @root_path + [attribute]
+
+                Issue.new(
+                  code,
+                  detail_for(code),
+                  path:,
+                  meta: build_meta(code, error),
+                )
+              end
+
+              def normalize_code(error)
+                return :invalid unless error.type.is_a?(Symbol)
+                return error.type if error.attribute == :base
+
+                CODE_MAP[error.type] || error.type
+              end
+
+              def detail_for(code)
+                result = @translator.call(:issues, code, :detail)
+                return result if result
+
+                DETAIL_MAP[code] || code.to_s.humanize
+              end
+
+              def build_meta(code, error)
+                return {} unless META_CODES.include?(code)
+                return {} unless error.options
+
+                if code == :in
+                  build_range_meta(error)
+                else
+                  build_numeric_meta(code, error)
+                end
+              end
+
+              def build_numeric_meta(code, error)
+                value = error.options[:count]
+                return {} unless value.is_a?(Numeric)
+
+                meta_key = code == :length ? :exact : code
+                { meta_key => value }
+              end
+
+              def build_range_meta(error)
+                range = error.options[:in]
+                return {} unless range.is_a?(Range)
+                return {} unless range.begin.is_a?(Numeric) && range.end.is_a?(Numeric)
+
+                {
+                  max: range.end,
+                  max_exclusive: range.exclude_end?,
+                  min: range.begin,
+                }
+              end
+
+              def resolve_attribute(attribute)
+                return attribute if attribute == :base
+                return attribute unless belongs_to_association?(attribute)
+
+                [attribute, 'id'].join('_').to_sym
+              end
+
+              def belongs_to_association?(attribute)
+                belongs_to_names.include?(attribute)
+              end
+
+              def belongs_to_names
+                @belongs_to_names ||= @record.class.reflect_on_all_associations(:belongs_to).map(&:name)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/apiwork/adapter/standard/capability/writing/operation.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Apiwork
+  module Adapter
+    class Standard
+      module Capability
+        class Writing
+          class Operation < Adapter::Capability::Operation::Base
+            target :member
+
+            def apply
+              validate_record!(data, representation_class)
+            end
+
+            private
+
+            def validate_record!(record, representation_class)
+              return unless record.respond_to?(:errors) && record.errors.any?
+
+              issues = IssueMapper.map(
+                record,
+                method(:translate),
+                root_path: [representation_class.root_key.singular.to_sym],
+              )
+              raise DomainError, issues
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/apiwork/adapter/standard/capability/writing/request_transformer.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Apiwork
+  module Adapter
+    class Standard
+      module Capability
+        class Writing < Adapter::Capability::Base
+          class RequestTransformer < Adapter::Capability::Transformer::Request::Base
+            phase :after
+
+            def transform
+              request.transform_body(&method(:transform_value))
+            end
+
+            private
+
+            def transform_value(value)
+              case value
+              when Hash then apply(value.transform_values(&method(:transform_value)))
+              when Array then value.map(&method(:transform_value))
+              else value
+              end
+            end
+
+            def apply(hash)
+              return hash unless hash.key?(Constants::OP)
+
+              result = hash.except(Constants::OP)
+              result[:_destroy] = true if hash[Constants::OP] == 'delete'
+              result
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/apiwork/adapter/standard/capability/writing.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Apiwork
+  module Adapter
+    class Standard
+      module Capability
+        class Writing < Adapter::Capability::Base
+          capability_name :writing
+
+          request_transformer RequestTransformer
+          contract_builder ContractBuilder
+          operation Operation
+        end
+      end
+    end
+  end
+end