mortymer 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c454029d3e20ca350725c27aa1352769467599d1dcc06fa91bc79eda2f63c967
-  data.tar.gz: f1a4f441ec003b1bcc7d54ad1451fdd11ef796802931f98c1d0ee765d0758c3d
+  metadata.gz: c13887be646cf5c591070d4d51c85e657c3509b11858d3d1cc7fa9650ec3c5ed
+  data.tar.gz: 0ca382da28037d53ab387f553854fc24047450b1b1d8589078f091130b15cbee
 SHA512:
-  metadata.gz: cde4a983859216b21cc13f9f5e582d3e47b4b6a7436fa17598afc0c69f750f0538fc0f95b71c298d876c0da03d78251e7d31868ab54d23f850dde3b1e30e6bb8
-  data.tar.gz: 47213cc011672d545cc97b97f2393f1064e3f658a883fec3352047034ea539991a795561879d13dea1a46fb9f953ccea0e2fa4f14875bc3759a4de1b881c898a
+  metadata.gz: 5fbe4192b479624078104e07290a0e6052eb7b752a59d566ad4501c197f325c97080ec00605654f9ecdda34a16f466a71fb0ea8807a6da0e08ed0b1bee65c1fd
+  data.tar.gz: 7da23bf7783533a1ba3dbe56ec41a800c5e1473ab22b51bd9d1fc4ab595dae81b43f48767c145d1d429b13c601d225d1599bbaff31746b263bea68aa19be4b9c

data/lib/mortymer/api_metadata.rb

@@ -50,6 +50,23 @@ module Mortymer
         register_endpoint(:delete, input, output, path, security || @__endpoint_security__)
       end
 
+      # Register an exception handler for the next endpoint
+      # @param exception [Class] The exception class to handle
+      # @param status [Symbol, Integer] The HTTP status code to return
+      # @param output [Class] The output schema class for the error response
+      # @yield [exception] Optional block to transform the exception into a response
+      # @yieldparam exception [Exception] The caught exception
+      # @yieldreturn [Hash] The response body
+      def handles_exception(exception, status: 400, output: nil, &block)
+        @__endpoint_exception_handlers__ ||= []
+        @__endpoint_exception_handlers__ << {
+          exception: exception,
+          status: status,
+          output: output,
+          handler: block
+        }
+      end
+
       private
 
       def method_added(method_name)
@@ -60,18 +77,30 @@ module Mortymer
           name: reflect_method_name(method_name), action: method_name
         ))
         input_class = @__endpoint_signature__[:input_class]
+        handlers = @__endpoint_signature__[:exception_handlers]
         @__endpoint_signature__ = nil
         return unless defined?(::Rails) && ::Rails.application.config.morty.wrap_methods
 
-        rails_wrap_method_with_no_params_call(method_name, input_class)
+        rails_wrap_method_with_no_params_call(method_name, input_class, handlers)
       end
 
-      def rails_wrap_method_with_no_params_call(method_name, input_class)
+      def rails_wrap_method_with_no_params_call(method_name, input_class, handlers)
         original_method = instance_method(method_name)
         define_method(method_name) do
-          input = input_class.new(params.to_unsafe_h.to_h.deep_transform_keys(&:to_sym))
+          input = input_class.structify(params.to_unsafe_h.to_h.deep_transform_keys(&:to_sym))
           output = original_method.bind_call(self, input)
           render json: output.to_h, status: :ok
+        rescue StandardError => e
+          handler = handlers.find { |h| e.is_a?(h[:exception]) }
+          raise unless handler
+
+          response = if handler[:handler]
+                       handler[:handler].call(e)
+                     else
+                       { error: e.message || e.class.name.underscore }
+                     end
+
+          render json: response, status: handler[:status]
         end
       end
 
@@ -84,8 +113,10 @@ module Mortymer
             path: path,
             controller_class: self,
             security: security,
-            tags: @__endpoint_tags__ || __default_tag_for_endpoint__
+            tags: @__endpoint_tags__ || __default_tag_for_endpoint__,
+            exception_handlers: [*(@__endpoint_exception_handlers__ || [])]
           }
+        @__endpoint_exception_handlers__ = nil
       end
 
       def reflect_method_name(method_name)

data/lib/mortymer/configuration.rb

@@ -19,7 +19,7 @@ module Mortymer
   # Global configuration for Mortymer
   class Configuration
     attr_accessor :container, :serve_swagger, :swagger_title, :swagger_path, :swagger_root, :api_version,
-                  :api_description, :security_schemes
+                  :api_description, :security_schemes, :api_prefix
 
     def initialize
       @container = Mortymer::Container.new
@@ -30,6 +30,7 @@ module Mortymer
       @api_description = "An awsome API developed with MORTYMER"
       @api_version = "v1"
       @security_schemes = {}
+      @api_prefix = "/api/v1"
     end
   end
 end

data/lib/mortymer/contract.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "moldeable"
+require "dry/validation"
+require "dry/validation/contract"
+require_relative "generator"
+
+module Mortymer
+  # A base model for defining schemas
+  class Contract < Dry::Validation::Contract
+    include Mortymer::Moldeable
+
+    # Exception raised when an error occours in a contract
+    class ContractError < StandardError
+      attr_reader :errors
+
+      def initialize(errors)
+        super
+        @errors = errors
+      end
+    end
+
+    def self.json_schema
+      Generator.new.from_validation(self)
+    end
+
+    def self.structify(params)
+      result = new.call(params)
+      raise ContractError.new(result.errors.to_h) unless result.errors.empty?
+
+      result.to_h
+    end
+  end
+end

data/lib/mortymer/dependencies_dsl.rb

@@ -52,7 +52,7 @@ module Mortymer
         container ||= Mortymer.config&.container || Container.new
         self.class.dependencies.each do |dep|
           value = if overrides.key?(dep[:var_name].to_sym)
-                    overrides[dep[:var_name].to_sym]
+                    overrides.delete(dep[:var_name].to_sym)
                   else
                     container.resolve_constant(dep[:constant])
                   end

data/lib/mortymer/dry_swagger.rb

@@ -1,15 +1,30 @@
 # frozen_string_literal: true
 
 require "dry_struct_parser/struct_schema_parser"
+require "dry_validation_parser/validation_schema_parser"
+require "dry/swagger/documentation_generator"
+require "dry/swagger/errors/missing_hash_schema_error"
+require "dry/swagger/errors/missing_type_error"
+require "dry/swagger/config/configuration"
+require "dry/swagger/config/swagger_configuration"
+require "dry/swagger/railtie" if defined?(Rails)
 
 # Need to monkey patch the nominal visitor for dry struct parser
 # as it currently does nothing with this field
 module DryStructParser
+  # Just to monkey patch it
   class StructSchemaParser
-    def visit_constructor(node, opts)
+    def visit_constructor(node, opts) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
       # Handle coercible types which have the form:
       # [:constructor, [[:nominal, [Type, {}]], [:method, Kernel, :Type]]]
       if node[0].is_a?(Array) && node[0][0] == :nominal
+        if node[0][1][0] == Mortymer::Types::RackFile
+          keys[opts[:key]] = node[0][1][1][:swagger].merge(
+            required: opts.fetch(:required, true),
+            nullable: opts.fetch(:nullable, false)
+          )
+          return
+        end
         required = opts.fetch(:required, true)
         nullable = opts.fetch(:nullable, false)
         type = node[0][1][0] # Get the type from nominal node
@@ -30,11 +45,3 @@ module DryStructParser
     end
   end
 end
-
-require "dry_validation_parser/validation_schema_parser"
-require "dry/swagger/documentation_generator"
-require "dry/swagger/errors/missing_hash_schema_error"
-require "dry/swagger/errors/missing_type_error"
-require "dry/swagger/config/configuration"
-require "dry/swagger/config/swagger_configuration"
-require "dry/swagger/railtie" if defined?(Rails)

data/lib/mortymer/endpoint.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
+require_relative "generator"
+
 module Mortymer
   # Represents an endpoint in a given system
-  class Endpoint
+  class Endpoint # rubocop:disable Metrics/ClassLength
     attr_reader :http_method, :path, :input_class, :output_class, :controller_class, :action, :name
 
     def initialize(opts = {})
@@ -15,6 +17,7 @@ module Mortymer
       @action = opts[:action]
       @security = opts[:security]
       @tags = opts[:tags]
+      @exception_handlers = opts[:exception_handlers]
     end
 
     def routeable?
@@ -36,20 +39,11 @@ module Mortymer
       end.join("/")
     end
 
-    def generate_openapi_schema # rubocop:disable Metrics/MethodLength
+    def generate_openapi_schema # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
       return unless defined?(@input_class) && defined?(@output_class)
 
-      input_schema = @input_class.respond_to?(:json_schema) ? @input_class.json_schema : Dry::Swagger::DocumentationGenerator.new.from_struct(@input_class)
-      responses = {
-        "200" => {
-          description: "Successful response",
-          content: {
-            "application/json" => {
-              schema: class_ref(@output_class)
-            }
-          }
-        }
-      }
+      input_schema = @input_class.respond_to?(:json_schema) ? @input_class.json_schema : Generator.new.from_struct(@input_class)
+      responses = generate_responses
 
       # Add 422 response if there are required properties or non-string types that need coercion
       if validations?(input_schema)
@@ -70,6 +64,7 @@ module Mortymer
         responses: responses,
         tags: @tags
       }
+
       operation[:security] = security if @security
       {
         path.to_s => {
@@ -80,6 +75,49 @@ module Mortymer
 
     private
 
+    def generate_responses
+      responses = {
+        "200" => {
+          description: "Successful response",
+          content: {
+            "application/json" => {
+              schema: class_ref(@output_class)
+            }
+          }
+        }
+      }
+
+      @exception_handlers&.each do |handler|
+        status_code = if handler[:status].is_a?(Symbol)
+                        Rack::Utils::SYMBOL_TO_STATUS_CODE[handler[:status]].to_s
+                      else
+                        handler[:status].to_s
+                      end
+
+        responses[status_code] = {
+          description: handler[:exception].name,
+          content: {
+            "application/json" => {
+              schema: if handler[:output]
+                        class_ref(handler[:output])
+                      else
+                        {
+                          type: "object",
+                          properties: {
+                            error: {
+                              type: "string"
+                            }
+                          }
+                        }
+                      end
+            }
+          }
+        }
+      end
+
+      responses
+    end
+
     def validations?(schema)
       return false unless schema
 
@@ -111,7 +149,7 @@ module Mortymer
       schema = if @input_class.respond_to?(:json_schema)
                  @input_class.json_schema
                else
-                 Dry::Swagger::DocumentationGenerator.new.from_struct(@input_class)
+                 Generator.new.from_struct(@input_class)
                end
       schema[:properties]&.map do |name, property|
         {
@@ -126,10 +164,22 @@ module Mortymer
     def generate_request_body
       return unless @input_class && %i[post put].include?(@http_method)
 
+      schema = if @input_class.respond_to?(:json_schema)
+                 @input_class.json_schema
+               else
+                 Generator.new.from_struct(@input_class)
+               end
+
+      # Check if any property is a File type
+      has_file = schema[:properties]&.any? do |_, property|
+        property[:format] == :binary
+      end
+
+      content_type = has_file ? "multipart/form-data" : "application/json"
       {
         required: true,
         content: {
-          "application/json" => {
+          content_type => {
             schema: class_ref(@input_class)
           }
         }

data/lib/mortymer/generator.rb

@@ -0,0 +1,115 @@
+require "dry/swagger"
+
+module Mortymer
+  class Generator < Dry::Swagger::DocumentationGenerator
+    SWAGGER_FIELD_TYPE_DEFINITIONS = {
+      "string" => { type: :string },
+      "integer" => { type: :integer },
+      "boolean" => { type: :boolean },
+      "float" => { type: :float },
+      "decimal" => { type: :string, format: :decimal },
+      "datetime" => { type: :string, format: :datetime },
+      "date" => { type: :string, format: :date },
+      "time" => { type: :string, format: :time },
+      "uuid" => { type: :string, format: :uuid },
+      "file" => { type: :string, format: :binary }
+    }.freeze
+
+    def from_struct(struct)
+      generate_documentation(::DryStructParser::StructSchemaParser.new.call(struct).keys)
+    end
+
+    def from_validation(validation)
+      generate_documentation(::DryValidationParser::ValidationSchemaParser.new.call(validation).keys)
+    end
+
+    def generate_documentation(fields)
+      documentation = { properties: {}, required: [] }
+      fields.each do |field_name, definition|
+        documentation[:properties][field_name] = generate_field_properties(definition)
+        if definition.is_a?(Hash)
+          documentation[:required] << field_name if definition.fetch(:required,
+                                                                     true) && @config.enable_required_validation
+        elsif definition[0].fetch(:required, true) && @config.enable_required_validation
+          documentation[:required] << field_name
+        end
+      end
+
+      { type: :object, properties: documentation[:properties], required: documentation[:required] }
+    end
+
+    def generate_field_properties(definition)
+      return generate_for_sti_type(definition) if definition.is_a?(Array)
+
+      documentation = if definition[:type] == "array" || definition[:array]
+                        generate_for_array(definition)
+                      elsif definition[:type] == "hash"
+                        generate_for_hash(definition)
+                      else
+                        generate_for_primitive_type(definition)
+                      end
+      if @config.enable_nullable_validation
+        documentation.merge(@config.nullable_type => definition.fetch(:nullable, false))
+      else
+        documentation.merge(@config.nullable_type => true)
+      end
+    rescue KeyError
+      raise Errors::MissingTypeError
+    end
+
+    def generate_for_sti_type(definition)
+      properties = {}
+
+      definition.each_with_index do |_, index|
+        properties["definition_#{index + 1}"] = generate_field_properties(definition[index])
+      end
+
+      documentation = {
+        type: :object,
+        properties: properties,
+        example: "Dynamic Field. See Model Definitions"
+      }
+
+      if definition[0][:type] == "array"
+        definition.each { |it| it[:type] = "hash" }
+        documentation[:oneOf] = definition.map { |it| generate_field_properties(it) }
+        { type: :array, items: documentation }
+      else
+        documentation[:oneOf] = definition.map { |it| generate_field_properties(it) }
+        documentation
+      end
+    end
+
+    def generate_for_array(definition)
+      items = if array_of_primitive_type?(definition)
+                self.class::SWAGGER_FIELD_TYPE_DEFINITIONS.fetch(definition.fetch(:type))
+              else
+                generate_documentation(definition.fetch(:keys))
+              end
+      items = if @config.enable_nullable_validation
+                items.merge(@config.nullable_type => definition.fetch(:nullable, false))
+              else
+                items.merge(@config.nullable_type => true)
+              end
+      { type: :array, items: items }
+    end
+
+    def generate_for_hash(definition)
+      raise Errors::MissingHashSchemaError unless definition[:keys]
+
+      generate_documentation(definition.fetch(:keys))
+    end
+
+    def generate_for_primitive_type(definition)
+      documentation = self.class::SWAGGER_FIELD_TYPE_DEFINITIONS.fetch(definition.fetch(:type))
+      documentation = documentation.merge(enum: definition.fetch(:enum)) if definition[:enum] && @config.enable_enums
+      documentation = documentation.merge(description: definition.fetch(:description)) if definition[:description] &&
+                                                                                          @config.enable_descriptions
+      documentation
+    end
+
+    def array_of_primitive_type?(definition)
+      definition[:array] && definition.fetch(:type) != "array"
+    end
+  end
+end

data/lib/mortymer/model.rb

@@ -1,8 +1,22 @@
 # frozen_string_literal: true
 
+require "dry/swagger/documentation_generator"
+require_relative "moldeable"
+require_relative "types"
+require_relative "generator"
+
 module Mortymer
   # A base model for defining schemas
   class Model < Dry::Struct
+    include Mortymer::Moldeable
     include Dry.Types()
+
+    def self.json_schema
+      Generator.new.from_struct(self)
+    end
+
+    def self.structify(params)
+      new(params)
+    end
   end
 end

data/lib/mortymer/moldeable.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Mortymer
+  # Interface for models to be able to be documentable
+  # and buildable from request inputs
+  module Moldeable
+    def self.json_schema
+      raise NotImplementedError
+    end
+
+    def self.structify(params = {})
+      raise NotImplementedError
+    end
+  end
+end

data/lib/mortymer/openapi_generator.rb

@@ -2,13 +2,14 @@
 
 require_relative "endpoint_registry"
 require_relative "utils/string_transformations"
+require_relative "generator"
 
 module Mortymer
   # Generate an openapi doc based on the registered endpoints
   class OpenapiGenerator
     include Utils::StringTransformations
 
-    def initialize(prefix: "", title: "Rick on Rails API", version: "v1", description: "", registry: [],
+    def initialize(prefix: "", title: "Rick on Rails API", version: "v1", description: "", registry: [], # rubocop:disable Metrics/ParameterLists
                    security_schemes: {})
       @prefix = prefix
       @title = title
@@ -73,7 +74,7 @@ module Mortymer
             if endpoint.input_class.respond_to?(:json_schema)
               endpoint.input_class.json_schema
             else
-              Dry::Swagger::DocumentationGenerator.new.from_struct(endpoint.input_class)
+              Generator.new.from_struct(endpoint.input_class)
             end
         end
 
@@ -83,7 +84,7 @@ module Mortymer
           if endpoint.output_class.respond_to?(:json_schema)
             endpoint.output_class.json_schema
           else
-            Dry::Swagger::DocumentationGenerator.new.from_struct(endpoint.output_class)
+            Generator.new.from_struct(endpoint.output_class)
           end
       end
       schemas

data/lib/mortymer/rails/routes.rb

@@ -28,7 +28,7 @@ module Mortymer
 
         @drawer.send(
           endpoint.http_method,
-          endpoint.path,
+          "#{Mortymer.config.api_prefix}#{endpoint.path}",
           to: "#{endpoint.controller_name.gsub(/_controller$/, "")}##{endpoint.action}",
           as: "#{endpoint.http_method}_#{endpoint.api_name}"
         )

data/lib/mortymer/railtie.rb

@@ -27,7 +27,8 @@ module Mortymer
             title: Mortymer.config.swagger_title,
             version: Mortymer.config.api_version,
             description: Mortymer.config.api_description,
-            security_schemes: Mortymer.config.security_schemes
+            security_schemes: Mortymer.config.security_schemes,
+            prefix: Mortymer.config.api_prefix
           )
 
           # Save OpenAPI spec to public directory

data/lib/mortymer/types.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "dry-types"
+
+module Mortymer
+  module Types
+    include Dry.Types()
+
+    class RackFile
+      attr_reader :tempfile, :original_filename, :content_type
+
+      def initialize(tempfile:, original_filename:, content_type:)
+        @tempfile = tempfile
+        @original_filename = original_filename
+        @content_type = content_type
+      end
+
+      def self.new_from_rack_file(file)
+        return nil if file.nil?
+
+        new(
+          tempfile: file.respond_to?(:tempfile) ? file.tempfile : file[:tempfile],
+          original_filename: file.respond_to?(:original_filename) ? file.original_filename : file[:original_filename],
+          content_type: file.respond_to?(:content_type) ? file.content_type : file[:content_type]
+        )
+      end
+    end
+
+    # Define a custom type for handling file uploads
+    UploadedFile = Types.Constructor(RackFile) do |value|
+      case value
+      when RackFile
+        value
+      when Hash
+        RackFile.new_from_rack_file(value)
+      when ActionDispatch::Http::UploadedFile
+        RackFile.new_from_rack_file(value)
+      when NilClass
+        nil
+      else
+        raise Dry::Types::CoercionError, "#{value.inspect} cannot be coerced to UploadedFile"
+      end
+    end.meta(
+      swagger: {
+        type: "file"
+      }
+    )
+
+    # Array of files
+    UploadedFiles = Types::Array.of(File)
+  end
+end

data/lib/mortymer/uploaded_file.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "types"
+
+UploadedFile = Mortymer::Types::UploadedFile

data/lib/mortymer/uploaded_files.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "types"
+
+UploadedFiles = Mortymer::Types::UploadedFiles

data/lib/mortymer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Mortymer
-  VERSION = "0.0.7"
+  VERSION = "0.0.8"
 end

data/lib/mortymer.rb

@@ -2,8 +2,13 @@
 # typed: true
 
 require "dry/struct"
+require "mortymer/types"
+require "mortymer/uploaded_file"
+require "mortymer/uploaded_files"
 require "mortymer/configuration"
+require "mortymer/moldeable"
 require "mortymer/model"
+require "mortymer/contract"
 require "mortymer/endpoint"
 require "mortymer/dry_swagger"
 require "mortymer/endpoint_registry"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mortymer
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors:
 - Adrian Gonzalez
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-03-11 00:00:00.000000000 Z
+date: 2025-03-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-monads
@@ -126,11 +126,14 @@ files:
 - lib/mortymer/api_metadata.rb
 - lib/mortymer/configuration.rb
 - lib/mortymer/container.rb
+- lib/mortymer/contract.rb
 - lib/mortymer/dependencies_dsl.rb
 - lib/mortymer/dry_swagger.rb
 - lib/mortymer/endpoint.rb
 - lib/mortymer/endpoint_registry.rb
+- lib/mortymer/generator.rb
 - lib/mortymer/model.rb
+- lib/mortymer/moldeable.rb
 - lib/mortymer/openapi_generator.rb
 - lib/mortymer/rails.rb
 - lib/mortymer/rails/configuration.rb
@@ -138,9 +141,11 @@ files:
 - lib/mortymer/rails/routes.rb
 - lib/mortymer/railtie.rb
 - lib/mortymer/security_schemes.rb
+- lib/mortymer/types.rb
+- lib/mortymer/uploaded_file.rb
+- lib/mortymer/uploaded_files.rb
 - lib/mortymer/utils/string_transformations.rb
 - lib/mortymer/version.rb
-- lib/mortymermer.rb
 - mortymer.gemspec
 - package-lock.json
 - package.json

data/lib/mortymermer.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-# typed: true
-
-require "dry/struct"
-require "mortymer/model"
-require "mortymer/endpoint"
-require "mortymer/dry_swagger"
-require "mortymer/endpoint_registry"
-require "mortymer/utils/string_transformations"
-require "mortymer/api_metadata"
-require "mortymer/openapi_generator"
-require "mortymer/container"
-require "mortymer/dependencies_dsl"
-require "mortymer/rails" if defined?(Rails)
-require "mortymer/railtie" if defined?(Rails::Railtie)