apiwork 0.0.0.pre → 0.1.2

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

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Apiwork
+  module Adapter
+    class Standard
+      module Capability
+        class Including
+          class ContractBuilder < Adapter::Capability::Contract::Base
+            TYPE_NAME = :include
+            MAX_RECURSION_DEPTH = 3
+
+            def build
+              return unless build_type(representation_class)
+
+              scope.actions.each_key do |action_name|
+                action(action_name) do |action|
+                  action.request do |request|
+                    request.query do |query|
+                      query.reference?(TYPE_NAME)
+                    end
+                  end
+                end
+              end
+            end
+
+            private
+
+            def build_type(representation_class, depth: 0, visited: Set.new)
+              return nil unless representation_class.associations.any?
+              return nil unless includable_params?(representation_class, depth:, visited:)
+
+              type_name = type_name_for(representation_class, depth)
+              return type_name if type?(type_name)
+              return type_name if depth >= MAX_RECURSION_DEPTH
+
+              visited = visited.dup.add(representation_class)
+
+              association_params = compute_association_params(
+                representation_class,
+                depth:,
+                visited:,
+              )
+
+              object(type_name) do |object|
+                association_params.each do |param_options|
+                  name = param_options[:name]
+                  include_type = param_options[:include_type]
+
+                  case param_options[:param_type]
+                  when :boolean
+                    object.boolean(name, optional: true) unless param_options[:include_mode] == :always
+                  when :reference
+                    object.reference(name, optional: true, to: include_type)
+                  when :union
+                    object.union(name, optional: true) do |union|
+                      union.variant(&:boolean)
+                      union.variant do |element|
+                        element.reference(include_type)
+                      end
+                    end
+                  end
+                end
+              end
+
+              type_name
+            end
+
+            def compute_association_params(representation_class, depth:, visited:)
+              representation_class.associations.filter_map do |name, association|
+                compute_single_association_param(name, association, representation_class, depth:, visited:)
+              end
+            end
+
+            def compute_single_association_param(name, association, representation_class, depth:, visited:)
+              if association.polymorphic?
+                return {
+                  name:,
+                  include_mode: association.include,
+                  include_type: nil,
+                  param_type: :boolean,
+                }
+              end
+
+              nested_representation_class = association.representation_class
+              return nil unless nested_representation_class
+
+              if visited.include?(nested_representation_class)
+                return {
+                  name:,
+                  include_mode: association.include,
+                  include_type: nil,
+                  param_type: :boolean,
+                }
+              end
+
+              include_type = resolve_association_include_type(
+                nested_representation_class,
+                depth:,
+                visited:,
+              )
+
+              if include_type.nil?
+                {
+                  include_type:,
+                  name:,
+                  include_mode: association.include,
+                  param_type: :boolean,
+                }
+              elsif association.include == :always
+                {
+                  include_type:,
+                  name:,
+                  include_mode: association.include,
+                  param_type: :reference,
+                }
+              else
+                {
+                  include_type:,
+                  name:,
+                  include_mode: association.include,
+                  param_type: :union,
+                }
+              end
+            end
+
+            def resolve_association_include_type(representation_class, depth:, visited:)
+              contract_class = contract_for(representation_class)
+              return build_type(representation_class, visited:, depth: depth + 1) unless contract_class
+
+              alias_name = representation_class.root_key.singular.to_sym
+              import(contract_class, as: alias_name)
+              imported_type = [alias_name, TYPE_NAME].join('_').to_sym
+              type?(imported_type) ? imported_type : nil
+            end
+
+            def includable_params?(representation_class, depth:, visited:)
+              return false if depth >= MAX_RECURSION_DEPTH
+
+              new_visited = visited.dup.add(representation_class)
+
+              representation_class.associations.values.any? do |association|
+                if association.polymorphic?
+                  association.include != :always
+                else
+                  nested_representation_class = association.representation_class
+                  next false unless nested_representation_class
+
+                  if new_visited.include?(nested_representation_class)
+                    association.include != :always
+                  elsif association.include == :always
+                    includable_params?(nested_representation_class, depth: depth + 1, visited: new_visited)
+                  else
+                    true
+                  end
+                end
+              end
+            end
+
+            def type_name_for(representation_class, depth)
+              return TYPE_NAME if depth.zero?
+
+              [representation_class.root_key.singular, TYPE_NAME].join('_').to_sym
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Apiwork
+  module Adapter
+    class Standard
+      module Capability
+        class Including
+          class Operation < Adapter::Capability::Operation::Base
+            def apply
+              params = request.query.fetch(:include, {})
+              includes = IncludesResolver.resolve(representation_class, params, include_always: true)
+
+              result(includes:, serialize_options: { include: params })
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Apiwork
+  module Adapter
+    class Standard
+      module Capability
+        class Including < Adapter::Capability::Base
+          capability_name :including
+
+          contract_builder ContractBuilder
+          operation Operation
+        end
+      end
+    end
+  end
+end

data/lib/apiwork/adapter/standard/capability/pagination/api_builder.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Apiwork
+  module Adapter
+    class Standard
+      module Capability
+        class Pagination
+          class APIBuilder < Adapter::Capability::API::Base
+            def build
+              return unless scope.index_actions?
+
+              if configured(:strategy).include?(:offset)
+                object(:offset_pagination) do |object|
+                  object.integer(:current)
+                  object.integer?(:next, nullable: true)
+                  object.integer?(:prev, nullable: true)
+                  object.integer(:total)
+                  object.integer(:items)
+                end
+              end
+
+              return unless configured(:strategy).include?(:cursor)
+
+              object(:cursor_pagination) do |object|
+                object.string?(:next, nullable: true)
+                object.string?(:prev, nullable: true)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Apiwork
+  module Adapter
+    class Standard
+      module Capability
+        class Pagination
+          class ContractBuilder < Adapter::Capability::Contract::Base
+            def build
+              return unless scope.action?(:index)
+
+              object(:page) do |object|
+                if options.strategy == :cursor
+                  object.string?(:after)
+                  object.string?(:before)
+                else
+                  object.integer?(:number, min: 1)
+                end
+                object.integer?(:size, max: options.max_size, min: 1)
+              end
+
+              action(:index) do |action|
+                action.request do |request|
+                  request.query do |query|
+                    query.reference?(:page)
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/apiwork/adapter/standard/capability/pagination/operation/paginate/cursor.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Apiwork
+  module Adapter
+    class Standard
+      module Capability
+        class Pagination
+          class Operation
+            module Paginate
+              class Cursor
+                class << self
+                  def apply(relation, config, params)
+                    new(relation, config, params).apply
+                  end
+                end
+
+                def initialize(relation, config, params)
+                  @relation = relation
+                  @config = config
+                  @params = params
+                end
+
+                def apply
+                  size = @params.fetch(:size, @config.default_size).to_i
+                  records = fetch_records(size)
+                  has_more = records.length > size
+                  records = records.first(size)
+
+                  { data: records, metadata: build_metadata(records, has_more) }
+                end
+
+                private
+
+                def fetch_records(size)
+                  table = @relation.klass.arel_table
+                  column = table[primary_key]
+
+                  if @params[:after]
+                    cursor_value = decode_cursor(@params[:after], field: :after)[primary_key]
+                    @relation.where(column.gt(cursor_value)).order(column.asc).limit(size + 1).to_a
+                  elsif @params[:before]
+                    cursor_value = decode_cursor(@params[:before], field: :before)[primary_key]
+                    @relation.where(column.lt(cursor_value)).order(column.desc).limit(size + 1).to_a.reverse
+                  else
+                    @relation.order(column.asc).limit(size + 1).to_a
+                  end
+                end
+
+                def primary_key
+                  return @primary_key if defined?(@primary_key)
+
+                  key = @relation.klass.primary_key
+                  raise NotImplementedError, 'Cursor pagination does not support composite primary keys' if key.is_a?(Array)
+
+                  @primary_key = key.to_sym
+                end
+
+                def build_metadata(records, has_more)
+                  {
+                    pagination: {
+                      next: has_more && records.any? ? encode_cursor(records.last) : nil,
+                      prev: (@params[:after] || @params[:before]) && records.any? ? encode_cursor(records.first) : nil,
+                    },
+                  }
+                end
+
+                def encode_cursor(record)
+                  Base64.urlsafe_encode64({ primary_key => record.public_send(primary_key) }.to_json)
+                end
+
+                def decode_cursor(cursor, field:)
+                  JSON.parse(Base64.urlsafe_decode64(cursor)).symbolize_keys
+                rescue ArgumentError, JSON::ParserError
+                  issue = Issue.new(:value_invalid, 'Invalid value', meta: { field:, expected: 'cursor' }, path: [:page, field])
+                  raise ContractError, issue
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/apiwork/adapter/standard/capability/pagination/operation/paginate/offset.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Apiwork
+  module Adapter
+    class Standard
+      module Capability
+        class Pagination
+          class Operation
+            module Paginate
+              class Offset
+                class << self
+                  def apply(relation, config, params)
+                    new(relation, config, params).apply
+                  end
+                end
+
+                def initialize(relation, config, params)
+                  @relation = relation
+                  @config = config
+                  @params = params
+                end
+
+                def apply
+                  number = @params.fetch(:number, 1).to_i
+                  size = [@params.fetch(:size, @config.default_size).to_i, 1].max
+
+                  {
+                    data: @relation.limit(size).offset((number - 1) * size),
+                    metadata: build_metadata(number, size),
+                  }
+                end
+
+                private
+
+                def build_metadata(number, size)
+                  items = count_items
+                  total = (items.to_f / size).ceil
+
+                  {
+                    pagination: {
+                      items:,
+                      total:,
+                      current: number,
+                      next: (number < total ? number + 1 : nil),
+                      prev: (number > 1 ? number - 1 : nil),
+                    },
+                  }
+                end
+
+                def count_items
+                  count_result = if @relation.joins_values.any?
+                                   @relation.except(:limit, :offset, :group).distinct.count(:all)
+                                 else
+                                   @relation.except(:limit, :offset, :group).count
+                                 end
+
+                  count_result.is_a?(Hash) ? count_result.size : count_result
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/apiwork/adapter/standard/capability/pagination/operation/paginate.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Apiwork
+  module Adapter
+    class Standard
+      module Capability
+        class Pagination
+          class Operation
+            module Paginate
+              class << self
+                def apply(data, options, params)
+                  case options.strategy
+                  when :offset then Offset.apply(data, options, params)
+                  when :cursor then Cursor.apply(data, options, params)
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Apiwork
+  module Adapter
+    class Standard
+      module Capability
+        class Pagination
+          class Operation < Adapter::Capability::Operation::Base
+            target :collection
+
+            metadata_shape do
+              reference(:pagination, to: (options.strategy == :cursor ? :cursor_pagination : :offset_pagination))
+            end
+
+            def apply
+              params = request.query.fetch(:page, {})
+              result(**Paginate.apply(data, options, params))
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Apiwork
+  module Adapter
+    class Standard
+      module Capability
+        class Pagination < Adapter::Capability::Base
+          capability_name :pagination
+
+          option :strategy, default: :offset, enum: %i[offset cursor], type: :symbol
+          option :default_size, default: 20, type: :integer
+          option :max_size, default: 100, type: :integer
+
+          api_builder APIBuilder
+          contract_builder ContractBuilder
+          operation Operation
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Apiwork
+  module Adapter
+    class Standard
+      module Capability
+        class Sorting
+          class APIBuilder < Adapter::Capability::API::Base
+            def build
+              return unless scope.sortable?
+
+              enum :sort_direction, values: %w[asc desc]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Apiwork
+  module Adapter
+    class Standard
+      module Capability
+        class Sorting
+          class ContractBuilder < Adapter::Capability::Contract::Base
+            TYPE_NAME = :sort
+
+            def build
+              return unless build_type
+
+              action(:index) do |action|
+                action.request do |request|
+                  request.query do |query|
+                    query.union?(TYPE_NAME) do |union|
+                      union.variant do |element|
+                        element.reference(TYPE_NAME)
+                      end
+                      union.variant do |element|
+                        element.array do |array|
+                          array.reference(TYPE_NAME)
+                        end
+                      end
+                    end
+                  end
+                end
+              end
+            end
+
+            private
+
+            def build_type
+              return unless sortable_content?
+
+              object(TYPE_NAME) do |object|
+                collect_attribute_sorts.each do |name|
+                  object.reference?(name, to: :sort_direction)
+                end
+
+                collect_association_sorts.each do |sort_config|
+                  object.reference?(sort_config[:name], to: sort_config[:type])
+                end
+              end
+            end
+
+            def collect_attribute_sorts
+              representation_class.attributes.filter_map do |name, attribute|
+                name if attribute.sortable?
+              end
+            end
+
+            def collect_association_sorts
+              representation_class.associations.filter_map do |name, association|
+                next unless association.sortable?
+                next if association.polymorphic?
+
+                representation = association.representation_class
+                next unless representation
+
+                contract = contract_for(representation)
+                next unless contract
+
+                alias_name = representation.root_key.singular.to_sym
+                import(contract, as: alias_name)
+
+                nested_type = [alias_name, TYPE_NAME].join('_').to_sym
+                next unless type?(nested_type)
+
+                { name:, type: nested_type }
+              end
+            end
+
+            def sortable_content?
+              representation_class.attributes.values.any?(&:sortable?) ||
+                representation_class.associations.values.any?(&:sortable?)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Apiwork
+  module Adapter
+    class Standard
+      module Capability
+        class Sorting
+          class Operation
+            class Sort
+              attr_reader :representation_class
+
+              class << self
+                def apply(relation, representation_class, params)
+                  new(relation, representation_class).apply(params)
+                end
+              end
+
+              def initialize(relation, representation_class)
+                @relation = relation
+                @representation_class = representation_class
+              end
+
+              def apply(params)
+                data = sort_data(params)
+                includes = IncludesResolver.resolve(representation_class, params)
+                { data:, includes: }
+              end
+
+              def build_order_clauses(params, target_klass = representation_class.model_class)
+                params.each_with_object([[], []]) do |(key, value), (orders, joins)|
+                  key = key.to_sym
+
+                  if value.is_a?(String) || value.is_a?(Symbol)
+                    attribute = representation_class.attributes[key]
+                    next unless attribute&.sortable?
+
+                    column = target_klass.arel_table[key]
+                    direction = value.to_sym
+
+                    case direction
+                    when :asc then orders << column.asc
+                    when :desc then orders << column.desc
+                    end
+
+                  elsif value.is_a?(Hash)
+                    association = target_klass.reflect_on_association(key)
+                    next unless association
+
+                    association_definition = representation_class.associations[key]
+                    next unless association_definition&.sortable?
+
+                    association_resource = association_definition.representation_class
+                    next unless association_resource
+
+                    nested_query = Sort.new(association.klass.all, association_resource)
+                    nested_orders, nested_joins = nested_query.build_order_clauses(value, association.klass)
+                    orders.concat(nested_orders)
+
+                    joins << (nested_joins.any? ? { key => nested_joins } : key)
+                  end
+                end
+              end
+
+              private
+
+              def sort_data(params)
+                return @relation if params.blank?
+
+                params = params.each_with_object({}) { |hash, acc| acc.merge!(hash) } if params.is_a?(Array)
+                return @relation unless params.is_a?(Hash)
+
+                orders, joins = build_order_clauses(params, representation_class.model_class)
+                scope = @relation.joins(joins).order(orders)
+                scope = scope.distinct if joins.present?
+                scope
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end