apiwork 0.0.0.pre → 0.1.2

data/lib/apiwork/introspection/dump/action.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Apiwork
+  module Introspection
+    module Dump
+      class Action
+        def initialize(contract_action)
+          @contract_action = contract_action
+        end
+
+        def to_h
+          {
+            deprecated: @contract_action.deprecated?,
+            description: @contract_action.description || i18n_lookup(:description),
+            operation_id: @contract_action.operation_id,
+            raises: raises,
+            request: build_request(@contract_action.request),
+            response: build_response(@contract_action.response),
+            summary: @contract_action.summary || i18n_lookup(:summary),
+            tags: @contract_action.tags || [],
+          }
+        end
+
+        private
+
+        def i18n_lookup(field)
+          contract_class = @contract_action.contract_class
+          return nil unless contract_class.name
+
+          contract_class.api_class.translate(
+            :contracts,
+            contract_class.name.demodulize.delete_suffix('Contract').underscore,
+            :actions,
+            @contract_action.name,
+            field,
+          )
+        end
+
+        def build_request(request)
+          return { body: {}, query: {} } unless request
+
+          {
+            body: build_param(request.body),
+            query: build_param(request.query),
+          }
+        end
+
+        def build_param(param)
+          param ? Param.new(param).to_h : {}
+        end
+
+        def build_response(response)
+          return { body: {}, no_content: false } unless response
+          return { body: {}, no_content: true } if response.no_content?
+
+          body_shape = response.body
+          return { body: {}, no_content: false } unless body_shape
+
+          { body: Param.new(body_shape, result_wrapper: response.result_wrapper).to_h, no_content: false }
+        end
+
+        def raises
+          (api_level_raises + @contract_action.raises + auto_raises).uniq.sort_by(&:to_s)
+        end
+
+        def api_level_raises
+          api_class = @contract_action.contract_class.api_class
+          return [] unless api_class
+
+          api_class.raises
+        end
+
+        def auto_raises
+          return [] unless @contract_action.contract_class.representation?
+
+          action_name = @contract_action.name.to_sym
+          return [:unprocessable_entity] if [:create, :update].include?(action_name)
+
+          return [] if [:index, :show, :destroy].include?(action_name)
+
+          http_method = find_http_method
+          return [] unless http_method
+
+          [:post, :patch, :put].include?(http_method) ? [:unprocessable_entity] : []
+        end
+
+        def find_http_method
+          api_class = @contract_action.contract_class.api_class
+          return nil unless api_class
+
+          resource = api_class.root_resource.find_resource do |candidate|
+            candidate.contract_class == @contract_action.contract_class
+          end
+          return nil unless resource
+
+          resource.actions[@contract_action.name.to_sym]&.method
+        end
+      end
+    end
+  end
+end

data/lib/apiwork/introspection/dump/api.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Apiwork
+  module Introspection
+    module Dump
+      class API
+        def initialize(api_class)
+          @api_class = api_class
+          @type_dump = Type.new(api_class)
+        end
+
+        def to_h
+          resources = build_resources
+          type_dump_hash = @type_dump.to_h
+
+          {
+            resources:,
+            base_path: @api_class.transform_path(@api_class.base_path),
+            enums: type_dump_hash[:enums],
+            error_codes: build_error_codes(collect_all_error_code_keys(resources)),
+            info: build_info,
+            types: type_dump_hash[:types],
+          }
+        end
+
+        private
+
+        def collect_all_error_code_keys(resources)
+          error_code_keys = Set.new(@api_class.raises)
+
+          collect_action_error_codes(resources, error_code_keys)
+
+          error_code_keys.to_a.sort_by(&:to_s)
+        end
+
+        def collect_action_error_codes(resources, error_code_keys)
+          resources.each_value do |resource|
+            resource[:actions].each_value do |action|
+              error_code_keys.merge(action[:raises] || [])
+            end
+
+            collect_action_error_codes(resource[:resources], error_code_keys) if resource[:resources]
+          end
+        end
+
+        def build_error_codes(error_code_keys)
+          error_code_keys.each_with_object({}) do |code, hash|
+            error_code = Apiwork::ErrorCode.find!(code)
+            hash[code] = {
+              description: error_code.description(locale_key: @api_class.locale_key),
+              status: error_code.status,
+            }
+          end
+        end
+
+        def build_resources
+          @api_class.root_resource.resources.transform_values do |resource|
+            Resource.new(resource, @api_class).to_h
+          end
+        end
+
+        def build_info
+          info = @api_class.info
+
+          title = resolve_info_text(info, :title)
+          summary = resolve_info_text(info, :summary)
+          description = resolve_info_text(info, :description)
+
+          return nil unless info || title || summary || description
+
+          {
+            description:,
+            summary:,
+            title:,
+            contact: build_contact(info&.contact),
+            deprecated: info ? info.deprecated? : false,
+            license: build_license(info&.license),
+            servers: build_servers(info ? info.server : []),
+            tags: info ? info.tags : [],
+            terms_of_service: info&.terms_of_service,
+            version: info&.version,
+          }
+        end
+
+        def resolve_info_text(info, field)
+          info&.public_send(field) || @api_class.translate(:info, field)
+        end
+
+        def build_contact(contact)
+          return nil unless contact
+
+          {
+            email: contact.email,
+            name: contact.name,
+            url: contact.url,
+          }
+        end
+
+        def build_license(license)
+          return nil unless license
+
+          {
+            name: license.name,
+            url: license.url,
+          }
+        end
+
+        def build_servers(servers)
+          servers.map do |server|
+            {
+              description: server.description,
+              url: server.url,
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/apiwork/introspection/dump/contract.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Apiwork
+  module Introspection
+    module Dump
+      class Contract
+        def initialize(contract_class, expand: false)
+          @contract_class = contract_class
+          @expand = expand
+          @type_dump = Type.new(contract_class.api_class)
+        end
+
+        def to_h
+          @contract_class.api_class.ensure_all_contracts_built!
+
+          result = { actions: {} }
+
+          action_names = available_actions
+          action_names = @contract_class.actions.keys if action_names.empty?
+
+          action_names.each do |action_name|
+            contract_action = @contract_class.action_for(action_name)
+            result[:actions][action_name] = Action.new(contract_action).to_h if contract_action
+          end
+
+          if @expand
+            types, enums = build_referenced_types_and_enums(result[:actions])
+          else
+            types = build_local_types
+            enums = build_local_enums
+          end
+
+          result[:types] = types
+          result[:enums] = enums
+
+          result
+        end
+
+        private
+
+        def build_local_types
+          @contract_class.api_class.type_registry.each_pair
+            .select { |_name, type_definition| type_definition.scope == @contract_class }
+            .reject { |_, type_definition| type_definition.fragment? }
+            .sort_by { |name, _type_definition| name.to_s }
+            .each_with_object({}) do |(name, type_definition), result|
+              result[name] = @type_dump.build_type(name, type_definition)
+          end
+        end
+
+        def build_local_enums
+          @contract_class.api_class.enum_registry.each_pair
+            .select { |_name, enum_definition| enum_definition.scope == @contract_class }
+            .sort_by { |name, _enum_definition| name.to_s }
+            .each_with_object({}) do |(name, enum_definition), result|
+              result[name] = @type_dump.build_enum(name, enum_definition)
+          end
+        end
+
+        def build_referenced_types_and_enums(actions_dump)
+          type_registry = @contract_class.api_class.type_registry
+          enum_registry = @contract_class.api_class.enum_registry
+
+          referenced_types = Set.new
+          referenced_enums = Set.new
+          dumped_types = {}
+          visited_types = Set.new
+
+          collect_references(actions_dump, referenced_types, referenced_enums)
+
+          until (pending_types = referenced_types - visited_types).empty?
+            pending_types.each do |type_name|
+              visited_types << type_name
+
+              type_definition = type_registry[type_name]
+              next unless type_definition
+
+              dumped = @type_dump.build_type(type_name, type_definition)
+              dumped_types[type_name] = dumped
+
+              collect_references(dumped, referenced_types, referenced_enums)
+            end
+          end
+
+          dumped_enums = referenced_enums.each_with_object({}) do |enum_name, result|
+            enum_definition = enum_registry[enum_name]
+            result[enum_name] = @type_dump.build_enum(enum_name, enum_definition) if enum_definition
+          end
+
+          types = dumped_types.sort_by { |name, _| name.to_s }.to_h
+          enums = dumped_enums.sort_by { |name, _| name.to_s }.to_h
+
+          [types, enums]
+        end
+
+        def collect_references(dump, types, enums)
+          case dump
+          when Hash
+            types << dump[:reference].to_sym if dump[:type] == :reference && dump[:reference]
+
+            types << dump[:of][:reference].to_sym if dump[:of].is_a?(Hash) && dump[:of][:type] == :reference && dump[:of][:reference]
+
+            enums << dump[:enum] if dump[:enum].is_a?(Symbol)
+
+            dump.each_value { |value| collect_references(value, types, enums) }
+          when Array
+            dump.each { |item| collect_references(item, types, enums) }
+          end
+        end
+
+        def available_actions
+          return [] unless resource
+
+          resource.actions.keys
+        end
+
+        def resource
+          @contract_class.api_class.root_resource.find_resource(resource_name)
+        end
+
+        def resource_name
+          return nil unless @contract_class.name
+
+          @contract_class.name.demodulize.delete_suffix('Contract').underscore.pluralize.to_sym
+        end
+      end
+    end
+  end
+end