funapi 0.1.0

data/lib/funapi/database/sequel/fibered_connection_pool.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+#
+# Taken from https://github.com/umbrellio/umbrellio-sequel-plugins?tab=readme-ov-file#fibered-connection-pool
+# Released under MIT License.
+# Created by Team Umbrellio.
+
+require "async"
+require "async/notification"
+
+class Sequel::FiberedConnectionPool < Sequel::ConnectionPool
+  def initialize(db, opts = Sequel::OPTS)
+    super
+
+    @max_connections = opts[:max_connections]
+    @available_connections = []
+    @notification = Async::Notification.new
+    @size = 0
+  end
+
+  def hold(*)
+    connection = wait_for_connection
+    return connection unless block_given?
+
+    begin
+      yield connection
+    rescue Sequel::DatabaseDisconnectError, *@error_classes => error
+      if disconnect_error?(error)
+        disconnect_connection(connection)
+        connection = nil
+        @size -= 1
+      end
+      raise
+    ensure
+      if connection
+        @available_connections.push(connection)
+        @notification.signal if Async::Task.current?
+      end
+    end
+  end
+
+  def disconnect(*)
+    @available_connections.each(&:close)
+    @available_connections.clear
+
+    @size = 0
+  end
+
+  attr_reader :size
+
+  private
+
+  def wait_for_connection
+    until (connection = find_or_create_connection)
+      @notification.wait
+    end
+
+    connection
+  end
+
+  def find_or_create_connection
+    if (connection = @available_connections.shift)
+      return connection
+    end
+
+    if @max_connections.nil? || @size < @max_connections
+      connection = make_new(:default)
+      @size += 1
+
+      return connection
+    end
+
+    nil
+  end
+end
+
+module Sequel::ConnectionPoolPatch
+  def connection_pool_class(*)
+    Sequel.current.is_a?(Fiber) ? Sequel::FiberedConnectionPool : super
+  end
+end
+
+class Sequel::ConnectionPool
+  class << self
+    prepend Sequel::ConnectionPoolPatch
+  end
+end

data/lib/funapi/dependency_wrapper.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module FunApi
+  class SimpleDependency
+    attr_reader :resource
+
+    def initialize(resource)
+      @resource = resource
+    end
+
+    def call
+      @resource
+    end
+
+    def cleanup
+    end
+  end
+
+  class ManagedDependency
+    attr_reader :resource, :cleanup_proc
+
+    def initialize(resource, cleanup_proc)
+      @resource = resource
+      @cleanup_proc = cleanup_proc
+    end
+
+    def call
+      @resource
+    end
+
+    def cleanup
+      @cleanup_proc&.call
+    end
+  end
+
+  class BlockDependency
+    def initialize(block)
+      @block = block
+      @fiber = nil
+      @resource = nil
+    end
+
+    def call
+      return @resource if @fiber
+
+      @fiber = Fiber.new do
+        result = nil
+        @block.call(proc { |resource|
+          result = resource
+          Fiber.yield resource
+        })
+        result
+      end
+
+      @resource = @fiber.resume
+      @resource
+    end
+
+    def cleanup
+      return unless @fiber
+
+      @fiber.resume if @fiber.alive?
+    rescue FiberError
+    end
+  end
+end

data/lib/funapi/depends.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module FunApi
+  class Depends
+    attr_reader :callable, :sub_dependencies
+
+    def initialize(callable, **sub_dependencies)
+      @callable = callable
+      @sub_dependencies = sub_dependencies
+
+      validate_callable!
+    end
+
+    def call(context, cache = {})
+      cache_key = object_id
+
+      return cache[cache_key] if cache.key?(cache_key)
+
+      resolved_deps, sub_cleanups = resolve_sub_dependencies(context, cache)
+      available_context = context.merge(resolved_deps)
+
+      result, cleanup = execute_callable(available_context)
+
+      combined_cleanup = if sub_cleanups.any? || cleanup
+        lambda {
+          sub_cleanups.each(&:call)
+          cleanup&.call
+        }
+      end
+
+      final_result = [result, combined_cleanup]
+      cache[cache_key] = final_result
+      final_result
+    end
+
+    private
+
+    def validate_callable!
+      return if @callable.respond_to?(:call)
+
+      raise ArgumentError, "Dependency must be callable (respond to :call)"
+    end
+
+    def resolve_sub_dependencies(context, cache)
+      cleanups = []
+
+      resolved = @sub_dependencies.transform_values do |dep|
+        result = if dep.is_a?(Depends)
+          dep.call(context, cache)
+        elsif dep.is_a?(Symbol)
+          container = context[:container]
+          unless container&.respond_to?(:resolve)
+            raise ArgumentError, "Cannot resolve symbol dependency :#{dep} without container in context"
+          end
+
+          wrapper = container.resolve(dep)
+          resource = wrapper.call
+          [resource, nil]
+
+        elsif dep.respond_to?(:call)
+          Depends.new(dep).call(context, cache)
+        else
+          [dep, nil]
+        end
+
+        resource, cleanup = if result.is_a?(Array) && result.length == 2
+          result
+        else
+          [result, nil]
+        end
+
+        cleanups << cleanup if cleanup
+        resource
+      end
+
+      [resolved, cleanups]
+    end
+
+    def extract_resource_and_cleanup_from_result(result)
+      if result.is_a?(Array) && result.length == 2 && result[1].respond_to?(:call)
+        result
+      else
+        [result, nil]
+      end
+    end
+
+    def execute_callable(context)
+      params = extract_params(context)
+
+      result = if params.any?
+        @callable.call(**params)
+      else
+        @callable.call
+      end
+
+      handle_result(result)
+    end
+
+    def extract_params(context)
+      parameters = callable_parameters
+      return {} unless parameters
+
+      params = {}
+
+      parameters.each do |type, name|
+        next unless %i[keyreq key].include?(type)
+
+        if context.key?(name)
+          params[name] = context[name]
+        elsif type == :keyreq
+          raise ArgumentError, "missing keyword: :#{name}"
+        end
+      end
+
+      params
+    end
+
+    def callable_parameters
+      if @callable.respond_to?(:parameters)
+        @callable.parameters
+      elsif @callable.respond_to?(:method)
+        @callable.method(:call).parameters
+      end
+    end
+
+    def handle_result(result)
+      if result.is_a?(Array) && result.length == 2 && result[1].respond_to?(:call)
+        result
+      else
+        [result, nil]
+      end
+    end
+  end
+
+  def self.Depends(callable, **sub_dependencies)
+    Depends.new(callable, **sub_dependencies)
+  end
+end

data/lib/funapi/exceptions.rb

@@ -0,0 +1,72 @@
+module FunApi
+  class HTTPException < StandardError
+    attr_reader :status_code, :detail, :headers
+
+    def initialize(status_code:, detail: nil, headers: nil)
+      @status_code = status_code
+      @detail = detail || default_detail
+      @headers = headers || {}
+      super(@detail.to_s)
+    end
+
+    def to_response
+      [
+        status_code,
+        {"content-type" => "application/json"}.merge(headers),
+        [JSON.dump(detail: detail)]
+      ]
+    end
+
+    private
+
+    def default_detail
+      case status_code
+      when 400 then "Bad Request"
+      when 401 then "Unauthorized"
+      when 403 then "Forbidden"
+      when 404 then "Not Found"
+      when 422 then "Unprocessable Entity"
+      when 500 then "Internal Server Error"
+      else "Error"
+      end
+    end
+  end
+
+  class ValidationError < HTTPException
+    attr_reader :errors
+
+    def initialize(errors:, headers: nil)
+      @errors = errors
+      super(status_code: 422, detail: format_errors(errors), headers: headers)
+    end
+
+    def to_response
+      [
+        status_code,
+        {"content-type" => "application/json"}.merge(headers),
+        [JSON.dump(detail: detail)]
+      ]
+    end
+
+    private
+
+    def format_errors(errors)
+      errors.messages.map do |error|
+        {
+          loc: error.path.map(&:to_s),
+          msg: error.text,
+          type: "value_error"
+        }
+      end
+    end
+  end
+
+  class TemplateNotFoundError < StandardError
+    attr_reader :template_name
+
+    def initialize(template_name)
+      @template_name = template_name
+      super("Template not found: #{template_name}")
+    end
+  end
+end

data/lib/funapi/middleware/base.rb

@@ -0,0 +1,13 @@
+module FunApi
+  module Middleware
+    class Base
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/funapi/middleware/cors.rb

@@ -0,0 +1,23 @@
+module FunApi
+  module Middleware
+    class Cors
+      def self.new(app, allow_origins: ["*"], allow_methods: ["*"],
+        allow_headers: ["*"], expose_headers: [],
+        max_age: 600, allow_credentials: false)
+        require "rack/cors"
+
+        Rack::Cors.new(app) do |config|
+          config.allow do |allow|
+            allow.origins(*allow_origins)
+            allow.resource "*",
+              methods: allow_methods,
+              headers: allow_headers,
+              expose: expose_headers,
+              max_age: max_age,
+              credentials: allow_credentials
+          end
+        end
+      end
+    end
+  end
+end

data/lib/funapi/middleware/request_logger.rb

@@ -0,0 +1,32 @@
+require "logger"
+
+module FunApi
+  module Middleware
+    class RequestLogger
+      def initialize(app, **options)
+        @app = app
+        @logger = options[:logger] || Logger.new($stdout)
+        @level = options[:level] || :info
+      end
+
+      def call(env)
+        start = Time.now
+        status, headers, body = @app.call(env)
+        duration = Time.now - start
+
+        log_request(env, status, duration)
+
+        [status, headers, body]
+      end
+
+      private
+
+      def log_request(env, status, duration)
+        request = Rack::Request.new(env)
+        @logger.send(@level,
+          "#{request.request_method} #{request.path} " \
+          "#{status} #{(duration * 1000).round(2)}ms")
+      end
+    end
+  end
+end

data/lib/funapi/middleware/trusted_host.rb

@@ -0,0 +1,34 @@
+module FunApi
+  module Middleware
+    class TrustedHost
+      def initialize(app, **options)
+        @app = app
+        @allowed_hosts = Array(options[:allowed_hosts] || [])
+      end
+
+      def call(env)
+        host = env["HTTP_HOST"]&.split(":")&.first
+
+        unless host_allowed?(host)
+          return [
+            400,
+            {"content-type" => "application/json"},
+            [JSON.dump(detail: "Invalid host header")]
+          ]
+        end
+
+        @app.call(env)
+      end
+
+      private
+
+      def host_allowed?(host)
+        return true if @allowed_hosts.empty?
+
+        @allowed_hosts.any? do |pattern|
+          pattern.is_a?(Regexp) ? pattern.match?(host) : pattern == host
+        end
+      end
+    end
+  end
+end

data/lib/funapi/middleware.rb

@@ -0,0 +1,4 @@
+require_relative "middleware/base"
+require_relative "middleware/cors"
+require_relative "middleware/trusted_host"
+require_relative "middleware/request_logger"

data/lib/funapi/openapi/schema_converter.rb

@@ -0,0 +1,85 @@
+module FunApi
+  module OpenAPI
+    class SchemaConverter
+      def self.to_json_schema(dry_schema, schema_name = nil)
+        return nil unless dry_schema
+
+        if dry_schema.is_a?(Array) && dry_schema.length == 1
+          return {
+            type: "array",
+            items: to_json_schema(dry_schema.first, schema_name)
+          }
+        end
+
+        properties = {}
+        required = []
+
+        dry_schema.rules.each do |key, rule|
+          field_name = key.to_s
+          field_info = extract_field_info(rule)
+
+          properties[field_name] = field_info[:schema]
+          required << field_name if field_info[:required]
+        end
+
+        schema = {
+          type: "object",
+          properties: properties
+        }
+
+        schema[:required] = required unless required.empty?
+        schema
+      end
+
+      def self.extract_field_info(rule)
+        rule_str = rule.to_s
+        is_required = rule.class.name.include?("And")
+
+        type_info = if rule_str.include?("array?")
+          items_type = if rule_str.include?("str?")
+            {type: "string"}
+          elsif rule_str.include?("int?")
+            {type: "integer"}
+          elsif rule_str.include?("float?") || rule_str.include?("decimal?")
+            {type: "number"}
+          elsif rule_str.include?("bool?")
+            {type: "boolean"}
+          else
+            {}
+          end
+          {type: "array", items: items_type}
+        elsif rule_str.include?("hash?")
+          {type: "object"}
+        elsif rule_str.include?("str?")
+          {type: "string"}
+        elsif rule_str.include?("int?")
+          {type: "integer"}
+        elsif rule_str.include?("float?") || rule_str.include?("decimal?")
+          {type: "number"}
+        elsif rule_str.include?("bool?")
+          {type: "boolean"}
+        else
+          {type: "string"}
+        end
+
+        {
+          schema: type_info,
+          required: is_required
+        }
+      end
+
+      def self.extract_schema_name(schema_obj)
+        ObjectSpace.each_object(Class).each do |klass|
+          klass.constants.each do |const_name|
+            const_value = klass.const_get(const_name)
+            return const_name.to_s if const_value == schema_obj
+          rescue
+            next
+          end
+        end
+
+        nil
+      end
+    end
+  end
+end