mortymer 0.0.6 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 23f37db069ed2b34095d8c6d60bb257478af6544361fd4bc61349bdb8d764ca7
-  data.tar.gz: 6dd9aa47b963f63de8f5f50a6e81341e4f090d0deeff244d2f8094e468438f03
+  metadata.gz: c13887be646cf5c591070d4d51c85e657c3509b11858d3d1cc7fa9650ec3c5ed
+  data.tar.gz: 0ca382da28037d53ab387f553854fc24047450b1b1d8589078f091130b15cbee
 SHA512:
-  metadata.gz: ce8c2077ad575b4c7cc289d14d2cddbb8c3a7f8c970f57f8a57df6046a13df05dfc7836b679784b641092214ba938e028661dc57b7ef7ac281dd6c453e415ced
-  data.tar.gz: f87678c7131a5abefe616819e42befc9b0065ac7e6d31a5e8800bf3806d63fa903e22f7f8006b6d3a10cbfcd66dbb8980a948823e59ce23a8a8144d76fb94473
+  metadata.gz: 5fbe4192b479624078104e07290a0e6052eb7b752a59d566ad4501c197f325c97080ec00605654f9ecdda34a16f466a71fb0ea8807a6da0e08ed0b1bee65c1fd
+  data.tar.gz: 7da23bf7783533a1ba3dbe56ec41a800c5e1473ab22b51bd9d1fc4ab595dae81b43f48767c145d1d429b13c601d225d1599bbaff31746b263bea68aa19be4b9c

data/docs/guide/quick-start.md

@@ -27,21 +27,6 @@ Then install it:
 bundle install
 ```
 
-Mortymer requires that every class is autoloaded for it to work. This is deafault rails
-behavior when running in production, but it is disabled by default on development, so,
-we first need to enable eager load
-
-```ruby
-# config/environments/development.rb
-Rails.application.configure do
-  # Settings specified here will take precedence over those in config/application.rb.
-
-  config.eager_load = true # This line is false by default, change it to true
-
-  # other configs hers ...
-end
-```
-
 In rails environments, Mortymer can automatically create the routes for you, it is not necessary
 that you register them one by one.
 
@@ -109,11 +94,10 @@ end
 Set up your API controller with Mortymer's features:
 
 ```ruby
-# app/controllers/api/books_controller.rb
-module Api
-  class BooksController < ApplicationController
-    include Mortymer::DependeciesDsl
+# app/controllers/example_controller.rb
+class ExampleController < ApplicationController
     include Mortymer::ApiMetadata
+    include Mortymer::DependenciesDsl
 
     inject BookService, as: :books
 
@@ -130,13 +114,13 @@ module Api
       attribute :published_year, Coercible::Integer
     end
 
-    # GET /api/books
-    get input: Empty, output: ListAllBooksOutput
+    tags :Books
+
+    get input: Empty, output: ListAllBooksOutput, path: "/examples/list_books"
     def list_all_books(_params)
       ListAllBooksOutput.new(books: @books.list_books)
     end
 
-    # POST /api/books
     post input: CreateBookInput, output: Book
     def create_book(params)
       @books.create_book(
@@ -145,7 +129,6 @@ module Api
         published_year: params.published_year
       )
     end
-  end
 end
 ```
 
@@ -182,3 +165,16 @@ This simple example showcases several of Mortymer's powerful features:
 - ✨ **Type System**: Strong typing with `Mortymer::Models` which are powered by `Dry::Struct`
 - 🔌 **Dependency Injection**: Clean service injection with `inject :book_service`
 - ✅ **Parameter Validation**: Built-in request validation in controllers
+
+## OpenAPI Documentation
+
+Mortymer automatically generates OpenAPI (Swagger) documentation for your API endpoints. After setting up your application, you can access the Swagger UI at `/api-docs`:
+
+![Swagger UI](../assets/swagg.png)
+
+This interactive documentation allows you to:
+
+- Browse all available endpoints
+- See request/response schemas
+- Test API endpoints directly from the browser
+- Download the OpenAPI specification

data/lib/mortymer/api_metadata.rb

@@ -15,20 +15,56 @@ module Mortymer
 
     # The DSL
     module ClassMethods
-      def get(input:, output:, path: nil)
-        register_endpoint(:get, input, output, path)
+      def secured_with(security)
+        @__endpoint_security__ = security
       end
 
-      def post(input:, output:, path: nil)
-        register_endpoint(:post, input, output, path)
+      def remove_security!
+        @__endpoint_security__ = nil
       end
 
-      def put(input:, output:, path: nil)
-        register_endpoint(:put, input, output, path)
+      def tags(*tag_list)
+        @__endpoint_tags__ = tag_list
       end
 
-      def delete(input:, output:, path: nil)
-        register_endpoint(:delete, input, output, path)
+      def __default_tag_for_endpoint__
+        # Assuming the endpoint is always defined inside a module
+        # the Tag would be the module of that endpoint. If no module, then
+        # we take the endpoint and remove any endpoint, controller suffix
+        [name.split("::").last(2).first] || [name.gsub(/Controller$/, "").gsub(/Endpoint$/, "")]
+      end
+
+      def get(input:, output:, path: nil, security: nil)
+        register_endpoint(:get, input, output, path, security || @__endpoint_security__)
+      end
+
+      def post(input:, output:, path: nil, security: nil)
+        register_endpoint(:post, input, output, path, security || @__endpoint_security__)
+      end
+
+      def put(input:, output:, path: nil, security: nil)
+        register_endpoint(:put, input, output, path, security || @__endpoint_security__)
+      end
+
+      def delete(input:, output:, path: nil, security: nil)
+        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
@@ -41,30 +77,46 @@ 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
 
-      def register_endpoint(http_method, input_class, output_class, path)
+      def register_endpoint(http_method, input_class, output_class, path, security)
         @__endpoint_signature__ =
           {
             http_method: http_method,
             input_class: input_class,
             output_class: output_class,
             path: path,
-            controller_class: self
+            controller_class: self,
+            security: security,
+            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
+                  :api_description, :security_schemes, :api_prefix
 
     def initialize
       @container = Mortymer::Container.new
@@ -29,6 +29,8 @@ module Mortymer
       @swagger_root = "/api-docs"
       @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 = {})
@@ -13,6 +15,9 @@ module Mortymer
       @path = opts[:path] || infer_path_from_class
       @controller_class = opts[:controller_class]
       @action = opts[:action]
+      @security = opts[:security]
+      @tags = opts[:tags]
+      @exception_handlers = opts[:exception_handlers]
     end
 
     def routeable?
@@ -34,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 = 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)
@@ -61,20 +57,67 @@ module Mortymer
         }
       end
 
+      operation = {
+        operation_id: operation_id,
+        parameters: generate_parameters,
+        requestBody: generate_request_body,
+        responses: responses,
+        tags: @tags
+      }
+
+      operation[:security] = security if @security
       {
         path.to_s => {
-          http_method.to_s => {
-            operation_id: operation_id,
-            parameters: generate_parameters,
-            requestBody: generate_request_body,
-            responses: responses
-          }
+          http_method.to_s => operation
         }
       }
     end
 
     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
 
@@ -90,13 +133,23 @@ module Mortymer
       has_required || has_coercions
     end
 
+    def security
+      return [] if @security.nil?
+
+      return [{ @security => [] }] if @security.is_a?(Symbol)
+
+      return [@security.scheme] if @security.respond_to?(:scheme)
+
+      [@security]
+    end
+
     def generate_parameters
       return [] unless @input_class && %i[get delete].include?(@http_method)
 
       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|
         {
@@ -111,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,18 +2,21 @@
 
 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
       @version = version
       @description = description
       @endpoints_registry = registry
+      @security_schemes = security_schemes
     end
 
     def generate
@@ -21,7 +24,10 @@ module Mortymer
         openapi: "3.0.1",
         info: { title: @title, version: @version, description: @description },
         paths: generate_paths,
-        components: { schemas: generate_schemas }
+        components: {
+          schemas: generate_schemas,
+          securitySchemes: @security_schemes
+        }
       }
     end
 
@@ -32,8 +38,11 @@ module Mortymer
         next unless endpoint.routeable?
 
         schema = endpoint.generate_openapi_schema || {}
-        schema = schema.transform_keys { |k| @prefix + k }
-        paths.merge!(schema)
+        schema.each do |path, methods|
+          prefixed_path = @prefix + path
+          paths[prefixed_path] ||= {}
+          paths[prefixed_path].merge!(methods)
+        end
       end || {}
     end
 
@@ -62,13 +71,21 @@ module Mortymer
 
         if endpoint.input_class && !schemas.key?(demodulize(endpoint.input_class.name))
           schemas[demodulize(endpoint.input_class.name)] =
-            Dry::Swagger::DocumentationGenerator.new.from_struct(endpoint.input_class)
+            if endpoint.input_class.respond_to?(:json_schema)
+              endpoint.input_class.json_schema
+            else
+              Generator.new.from_struct(endpoint.input_class)
+            end
         end
 
-        if endpoint.output_class && !schemas.key?(demodulize(endpoint.output_class.name))
-          schemas[demodulize(endpoint.output_class.name)] =
-            Dry::Swagger::DocumentationGenerator.new.from_struct(endpoint.output_class)
-        end
+        next unless endpoint.output_class && !schemas.key?(demodulize(endpoint.output_class.name))
+
+        schemas[demodulize(endpoint.output_class.name)] =
+          if endpoint.output_class.respond_to?(:json_schema)
+            endpoint.output_class.json_schema
+          else
+            Generator.new.from_struct(endpoint.output_class)
+          end
       end
       schemas
     end

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

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

data/lib/mortymer/security_schemes.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Mortymer
+  module SecuritySchemes
+    # Define the Bearer Auth security scheme
+    class Bearer
+      def self.scheme(scopes = [].freeze)
+        { BearerAuth: scopes }
+      end
+
+      def self.to_scheme
+        {
+          BearerAuth: {
+            type: :http,
+            scheme: :bearer
+          }
+        }
+      end
+    end
+
+    # Define the API Key security scheme
+    class ApiKey
+      def self.scheme(scopes = [].freeze)
+        { ApiKeyAuth: scopes }
+      end
+
+      def self.to_scheme(name: "X-API-Key", in: :header)
+        {
+          ApiKeyAuth: {
+            type: :apiKey,
+            name: name,
+            in: binding.local_variable_get(:in) # Use binding because 'in' is a reserved word
+          }
+        }
+      end
+    end
+
+    # Define the Basic Auth security scheme
+    class Basic
+      def self.scheme(scopes = [].freeze)
+        { BasicAuth: scopes }
+      end
+
+      def self.to_scheme
+        {
+          BasicAuth: {
+            type: :http,
+            scheme: :basic
+          }
+        }
+      end
+    end
+
+    # Define the OAuth2 security scheme
+    class OAuth2
+      def self.scheme(scopes = [].freeze)
+        { OAuth2: scopes }
+      end
+
+      def self.to_scheme(flows: {})
+        {
+          OAuth2: {
+            type: :oauth2,
+            flows: flows || {
+              implicit: {
+                authorizationUrl: "/oauth/authorize",
+                scopes: {
+                  "read:api" => "Read access",
+                  "write:api" => "Write access"
+                }
+              },
+              password: {
+                tokenUrl: "/oauth/token",
+                scopes: {
+                  "read:api" => "Read access",
+                  "write:api" => "Write access"
+                }
+              }
+            }
+          }
+        }
+      end
+    end
+  end
+end

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.6"
+  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"
@@ -12,5 +17,6 @@ require "mortymer/api_metadata"
 require "mortymer/openapi_generator"
 require "mortymer/container"
 require "mortymer/dependencies_dsl"
+require "mortymer/security_schemes"
 require "mortymer/rails" if defined?(Rails)
 require "mortymer/railtie" if defined?(Rails::Railtie)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mortymer
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.8
 platform: ruby
 authors:
 - Adrian Gonzalez
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-03-10 00:00:00.000000000 Z
+date: 2025-03-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-monads
@@ -116,6 +116,7 @@ files:
 - docs/.vitepress/theme/style.css
 - docs/advanced/dependency-injection.md
 - docs/advanced/openapi.md
+- docs/assets/swagg.png
 - docs/guide/api-metadata.md
 - docs/guide/introduction.md
 - docs/guide/models.md
@@ -125,20 +126,26 @@ 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
 - lib/mortymer/rails/endpoint_wrapper_controller.rb
 - 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)