funapi 0.1.0

data/lib/funapi/openapi/spec_generator.rb

@@ -0,0 +1,179 @@
+require_relative "schema_converter"
+
+module FunApi
+  module OpenAPI
+    class SpecGenerator
+      def initialize(routes, info:)
+        @routes = routes
+        @info = info
+        @schemas = {}
+        @schema_counter = 0
+      end
+
+      def generate
+        {
+          openapi: "3.0.3",
+          info: build_info,
+          paths: build_paths,
+          components: build_components
+        }
+      end
+
+      private
+
+      def build_info
+        {
+          title: @info[:title],
+          version: @info[:version],
+          description: @info[:description]
+        }
+      end
+
+      def build_paths
+        paths = {}
+
+        @routes.each do |route|
+          next if route.metadata[:internal]
+
+          path_template = convert_path_template(route.metadata[:path_template])
+          paths[path_template] ||= {}
+
+          operation = build_operation(route)
+          paths[path_template][route.verb.downcase] = operation
+        end
+
+        paths
+      end
+
+      def build_operation(route)
+        operation = {}
+
+        parameters = []
+        parameters.concat(build_path_parameters(route))
+        parameters.concat(build_query_parameters(route))
+
+        operation[:parameters] = parameters unless parameters.empty?
+        operation[:requestBody] = build_request_body(route) if route.metadata[:body_schema]
+        operation[:responses] = build_responses(route)
+
+        operation
+      end
+
+      def build_path_parameters(route)
+        route.keys.map do |key|
+          {
+            name: key,
+            in: "path",
+            required: true,
+            schema: {type: "string"}
+          }
+        end
+      end
+
+      def build_query_parameters(route)
+        query_schema = route.metadata[:query_schema]
+        return [] unless query_schema
+
+        schema = unwrap_array_schema(query_schema)
+        json_schema = SchemaConverter.to_json_schema(schema)
+        return [] unless json_schema && json_schema[:properties]
+
+        required_fields = json_schema[:required] || []
+
+        json_schema[:properties].map do |name, prop_schema|
+          {
+            name: name.to_s,
+            in: "query",
+            required: required_fields.include?(name.to_s),
+            schema: prop_schema
+          }
+        end
+      end
+
+      def build_request_body(route)
+        body_schema = route.metadata[:body_schema]
+        return nil unless body_schema
+
+        schema_ref = register_schema(body_schema, route.verb, route.metadata[:path_template])
+
+        {
+          required: true,
+          content: {
+            "application/json": {
+              schema: schema_ref
+            }
+          }
+        }
+      end
+
+      def build_responses(route)
+        response_schema = route.metadata[:response_schema]
+
+        if response_schema
+          schema_ref = register_schema(response_schema, "#{route.verb}Response", route.metadata[:path_template])
+
+          {
+            "200": {
+              description: "Successful response",
+              content: {
+                "application/json": {
+                  schema: schema_ref
+                }
+              }
+            }
+          }
+        else
+          {
+            "200": {
+              description: "Successful response"
+            }
+          }
+        end
+      end
+
+      def register_schema(schema, verb, path)
+        schema_obj = unwrap_array_schema(schema)
+        is_array = schema.is_a?(Array)
+
+        schema_name = SchemaConverter.extract_schema_name(schema_obj)
+
+        unless schema_name
+          @schema_counter += 1
+          method_name = path.split("/").reject(&:empty?).map do |s|
+            s.start_with?(":") ? s[1..].capitalize : s.capitalize
+          end.join
+          schema_name = "#{method_name}#{verb.capitalize}Schema#{@schema_counter}"
+        end
+
+        @schemas[schema_name] = SchemaConverter.to_json_schema(schema_obj)
+
+        if is_array
+          {
+            type: "array",
+            items: {"$ref": "#/components/schemas/#{schema_name}"}
+          }
+        else
+          {"$ref": "#/components/schemas/#{schema_name}"}
+        end
+      end
+
+      def build_components
+        {
+          schemas: @schemas
+        }
+      end
+
+      def convert_path_template(path)
+        path.gsub(/:(\w+)/, '{\1}')
+      end
+
+      def unwrap_array_schema(schema)
+        if schema.is_a?(Array) && schema.length == 1
+          schema.first
+        else
+          schema
+        end
+      end
+    end
+  end
+end

data/lib/funapi/router.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module FunApi
+  class Router
+    Route = Struct.new(:verb, :pattern, :keys, :handler, :metadata)
+
+    def initialize
+      @routes = []
+    end
+
+    attr_reader :routes
+
+    def add(verb, path, metadata: {}, &handler)
+      keys = []
+
+      regex = if path == "/"
+        "/"
+      else
+        path.split("/").map do |seg|
+          if seg.start_with?(":")
+            keys << seg.delete_prefix(":")
+            "([^/]+)"
+          else
+            Regexp.escape(seg)
+          end
+        end.join("/")
+      end
+
+      route_metadata = metadata.merge(path_template: path)
+      @routes << Route.new(verb.upcase, /\A#{regex}\z/, keys, handler, route_metadata)
+    end
+
+    def call(env)
+      req = Rack::Request.new(env)
+      route = @routes.find { |r| r.verb == req.request_method && r.pattern =~ req.path_info }
+      return [404, {"content-type" => "application/json"}, [JSON.dump(error: "Not found")]] unless route
+
+      match = route.pattern.match(req.path_info)
+      params = route.keys.zip(match.captures).to_h
+      route.handler.call(req, params)
+    end
+  end
+end

data/lib/funapi/schema.rb

@@ -0,0 +1,65 @@
+require "dry-schema"
+
+module FunApi
+  class Schema
+    def self.define(&block)
+      Dry::Schema.Params(&block)
+    end
+
+    def self.validate(schema, data, location: "body")
+      return data unless schema
+
+      if schema.is_a?(Array) && schema.length == 1
+        item_schema = schema.first
+        data_array = data.is_a?(Array) ? data : []
+
+        results = data_array.map do |item|
+          result = item_schema.call(item || {})
+          raise ValidationError.new(errors: result.errors) unless result.success?
+
+          result.to_h
+        end
+
+        return results
+      end
+
+      result = schema.call(data || {})
+      raise ValidationError.new(errors: result.errors) unless result.success?
+
+      result.to_h
+    end
+
+    def self.validate_response(schema, data)
+      return data unless schema
+
+      if schema.is_a?(Array) && schema.length == 1
+        item_schema = schema.first
+        data_array = data.is_a?(Array) ? data : []
+
+        return data_array.map do |item|
+          result = item_schema.call(item)
+
+          unless result.success?
+            raise HTTPException.new(
+              status_code: 500,
+              detail: "Response validation failed: #{result.errors.to_h}"
+            )
+          end
+
+          result.to_h
+        end
+      end
+
+      result = schema.call(data)
+
+      unless result.success?
+        raise HTTPException.new(
+          status_code: 500,
+          detail: "Response validation failed: #{result.errors.to_h}"
+        )
+      end
+
+      result.to_h
+    end
+  end
+end

data/lib/funapi/server/falcon.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "falcon"
+require "protocol/rack"
+
+module FunApi
+  module Server
+    # Falcon server adapter - uses protocol-rack for proper Rack integration
+    class Falcon
+      def self.start(app, host: "0.0.0.0", port: 3000)
+        Async do |task|
+          falcon_app = Protocol::Rack::Adapter.new(app)
+          endpoint = ::Async::HTTP::Endpoint.parse("http://#{host}:#{port}").with(protocols: Async::HTTP::Protocol::HTTP2)
+
+          server = ::Falcon::Server.new(falcon_app, endpoint)
+
+          app.run_startup_hooks if app.respond_to?(:run_startup_hooks)
+
+          puts "Falcon listening on #{host}:#{port}"
+          puts "Try: curl http://#{host}:#{port}/hello"
+          puts "Press Ctrl+C to stop"
+
+          shutdown = -> {
+            puts "\nShutting down..."
+            app.run_shutdown_hooks if app.respond_to?(:run_shutdown_hooks)
+            task.stop
+            exit
+          }
+
+          trap(:INT) { shutdown.call }
+          trap(:TERM) { shutdown.call }
+
+          server.run
+        end
+      end
+    end
+  end
+end

data/lib/funapi/template_response.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module FunApi
+  class TemplateResponse
+    attr_reader :body, :status, :headers
+
+    def initialize(body, status: 200, headers: {})
+      @body = body
+      @status = status
+      @headers = {"content-type" => "text/html; charset=utf-8"}.merge(headers)
+    end
+
+    def to_response
+      [status, headers, [body]]
+    end
+  end
+end

data/lib/funapi/templates.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "erb"
+require "pathname"
+require_relative "template_response"
+require_relative "exceptions"
+
+module FunApi
+  class Templates
+    def initialize(directory:, layout: nil)
+      @directory = Pathname.new(directory)
+      @layout = layout
+      @cache = {}
+    end
+
+    def with_layout(layout)
+      ScopedTemplates.new(self, layout)
+    end
+
+    def render(name, layout: nil, **context)
+      content = render_template(name, **context)
+
+      layout_to_use = determine_layout(layout)
+      if layout_to_use
+        render_with_layout(layout_to_use, content, **context)
+      else
+        content
+      end
+    end
+
+    def response(name, status: 200, headers: {}, layout: nil, **context)
+      html = render(name, layout: layout, **context)
+      TemplateResponse.new(html, status: status, headers: headers)
+    end
+
+    def render_partial(name, **context)
+      render_template(name, **context)
+    end
+
+    private
+
+    def determine_layout(layout_override)
+      return nil if layout_override == false
+      return layout_override if layout_override
+
+      @layout
+    end
+
+    def render_with_layout(layout_name, content, **context)
+      template = load_template(layout_name)
+      template_context = TemplateContext.new(self, context, content: content)
+      template.result(template_context.get_binding)
+    end
+
+    def render_template(name, **context)
+      template = load_template(name)
+      template_context = TemplateContext.new(self, context)
+      template.result(template_context.get_binding)
+    end
+
+    def load_template(name)
+      path = @directory.join(name)
+      raise TemplateNotFoundError.new(name) unless path.exist?
+
+      @cache[name] ||= ERB.new(path.read, trim_mode: "-")
+    end
+  end
+
+  class TemplateContext
+    def initialize(templates, context, content: nil)
+      @templates = templates
+      @content = content
+      context.each do |key, value|
+        define_singleton_method(key) { value }
+      end
+    end
+
+    def render_partial(name, **context)
+      @templates.render_partial(name, **context)
+    end
+
+    def yield_content
+      @content
+    end
+
+    def get_binding
+      binding
+    end
+  end
+
+  class ScopedTemplates
+    def initialize(templates, layout)
+      @templates = templates
+      @layout = layout
+    end
+
+    def render(name, layout: nil, **context)
+      effective_layout = layout.nil? ? @layout : layout
+      @templates.render(name, layout: effective_layout, **context)
+    end
+
+    def response(name, status: 200, headers: {}, layout: nil, **context)
+      effective_layout = layout.nil? ? @layout : layout
+      @templates.response(name, status: status, headers: headers, layout: effective_layout, **context)
+    end
+
+    def render_partial(name, **context)
+      @templates.render_partial(name, **context)
+    end
+  end
+end

data/lib/funapi/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module FunApi
+  VERSION = "0.1.0"
+end

data/lib/funapi.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "funapi/version"
+require_relative "funapi/exceptions"
+require_relative "funapi/schema"
+require_relative "funapi/depends"
+require_relative "funapi/dependency_wrapper"
+require_relative "funapi/async"
+require_relative "funapi/router"
+require_relative "funapi/application"
+
+module FunApi
+  class Error < StandardError; end
+end