rubst_api 0.1.0

data/lib/rubst_api/model.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require "date"
+require "time"
+require "uri"
+
+module RubstApi
+  class ValidationError < StandardError
+    attr_reader :errors
+    def initialize(errors)
+      @errors = errors
+      super(errors.map { |e| e[:msg] }.join(", "))
+    end
+  end
+
+  class Model
+    Field = Data.define(:name, :type, :default, :required, :options)
+
+    class << self
+      def inherited(child)
+        child.instance_variable_set(:@fields, fields.dup)
+      end
+
+      def fields = @fields ||= {}
+
+      def field(name, type = String, default: UNDEFINED, required: nil, **options)
+        required = default.equal?(UNDEFINED) if required.nil?
+        fields[name.to_sym] = Field.new(name.to_sym, type, default, required, options.freeze)
+        attr_reader name
+      end
+
+      def validate(value, location: [:body])
+        return value if value.is_a?(self)
+        unless value.is_a?(Hash)
+          raise ValidationError, [{ type: "model_type", loc: location, msg: "Input should be an object", input: value }]
+        end
+        new(**value.transform_keys(&:to_sym))
+      rescue ValidationError => e
+        raise ValidationError, e.errors.map { |error| error.merge(loc: location + Array(error[:loc])) }
+      end
+
+      def json_schema(ref_template: "#/components/schemas/%s")
+        required = fields.values.select(&:required).map { |field| field.name.to_s }
+        {
+          type: "object",
+          title: name&.split("::")&.last,
+          properties: fields.to_h { |name, field| [name, Schema.for(field.type, field.options)] }
+        }.tap { |schema| schema[:required] = required unless required.empty? }
+      end
+    end
+
+    def initialize(**attributes)
+      errors = []
+      self.class.fields.each_value do |field|
+        value = attributes.key?(field.name) ? attributes[field.name] : field.default
+        if value.equal?(UNDEFINED)
+          errors << { type: "missing", loc: [field.name], msg: "Field required", input: attributes }
+          next
+        end
+        begin
+          instance_variable_set(:"@#{field.name}", Validator.coerce(value, field.type, field.options))
+        rescue ValidationError => e
+          errors.concat(e.errors.map { |error| error.merge(loc: [field.name] + Array(error[:loc])) })
+        end
+      end
+      raise ValidationError, errors unless errors.empty?
+      freeze
+    end
+
+    def model_dump(exclude_none: false, by_alias: false)
+      self.class.fields.each_with_object({}) do |(name, field), output|
+        value = public_send(name)
+        next if exclude_none && value.nil?
+        key = by_alias && field.options[:alias] ? field.options[:alias] : name
+        output[key] = Serializer.dump(value)
+      end
+    end
+    alias to_h model_dump
+
+    def to_json(*) = JSON.generate(model_dump)
+    def ==(other) = other.instance_of?(self.class) && other.model_dump == model_dump
+  end
+
+  module Validator
+    module_function
+
+    def coerce(value, type, constraints = {})
+      return nil if value.nil? && nullable?(type, constraints)
+      result =
+        if type.is_a?(Array)
+          validate_union(value, type, constraints)
+        elsif type.is_a?(Hash) && type.key?(:array)
+          Array(value).map { |item| coerce(item, type[:array], {}) }
+        elsif type.is_a?(Class) && type <= Model
+          type.validate(value, location: [])
+        elsif type == String then String(value)
+        elsif type == Integer then Integer(value, exception: true)
+        elsif type == Float then Float(value)
+        elsif type == Numeric then Float(value)
+        elsif type == TrueClass || type == FalseClass || type == :boolean then boolean(value)
+        elsif type == Symbol then value.to_sym
+        elsif type == Date then Date.parse(value.to_s)
+        elsif type == Time || type == DateTime then Time.parse(value.to_s)
+        elsif type == URI then URI.parse(value.to_s)
+        elsif type == Array then Array(value)
+        elsif type == Hash then Hash(value)
+        elsif type.respond_to?(:call) && !type.is_a?(Class) then type.call(value)
+        elsif value.is_a?(type) then value
+        else raise TypeError, "expected #{type}"
+        end
+      constrain(result, constraints)
+    rescue ValidationError
+      raise
+    rescue StandardError
+      raise ValidationError, [{ type: type_name(type), loc: [], msg: "Input should be a valid #{type_name(type)}", input: value }]
+    end
+
+    def nullable?(type, constraints) = constraints[:nullable] || (type.is_a?(Array) && type.include?(NilClass))
+
+    def validate_union(value, types, constraints)
+      return nil if value.nil? && types.include?(NilClass)
+      failures = []
+      types.reject { |type| type == NilClass }.each do |type|
+        return coerce(value, type, constraints)
+      rescue ValidationError => e
+        failures.concat(e.errors)
+      end
+      raise ValidationError, failures
+    end
+
+    def boolean(value)
+      return value if value == true || value == false
+      return true if %w[1 true on yes].include?(value.to_s.downcase)
+      return false if %w[0 false off no].include?(value.to_s.downcase)
+      raise TypeError
+    end
+
+    def constrain(value, options)
+      length = value.respond_to?(:length) ? value.length : nil
+      fail_constraint(value, "string_too_short", "Value is too short") if options[:min_length] && length && length < options[:min_length]
+      fail_constraint(value, "string_too_long", "Value is too long") if options[:max_length] && length && length > options[:max_length]
+      fail_constraint(value, "greater_than", "Value must be greater than #{options[:gt]}") if options[:gt] && !(value > options[:gt])
+      fail_constraint(value, "greater_than_equal", "Value must be greater than or equal to #{options[:ge]}") if options[:ge] && !(value >= options[:ge])
+      fail_constraint(value, "less_than", "Value must be less than #{options[:lt]}") if options[:lt] && !(value < options[:lt])
+      fail_constraint(value, "less_than_equal", "Value must be less than or equal to #{options[:le]}") if options[:le] && !(value <= options[:le])
+      pattern = options[:pattern] || options[:regex]
+      fail_constraint(value, "string_pattern_mismatch", "Value does not match pattern") if pattern && !(Regexp.new(pattern.to_s) =~ value.to_s)
+      fail_constraint(value, "enum", "Value is not an allowed option") if options[:enum] && !options[:enum].include?(value)
+      value
+    end
+
+    def fail_constraint(value, type, message)
+      raise ValidationError, [{ type:, loc: [], msg: message, input: value }]
+    end
+
+    def type_name(type)
+      { Integer => "integer", Float => "number", String => "string", TrueClass => "boolean",
+        FalseClass => "boolean", Hash => "object", Array => "array" }[type] || type.to_s.downcase
+    end
+  end
+
+  module Serializer
+    module_function
+    def dump(value)
+      case value
+      when Model then value.model_dump.transform_values { |item| dump(item) }
+      when Hash then value.to_h { |key, item| [key, dump(item)] }
+      when Array then value.map { |item| dump(item) }
+      when Time, Date, DateTime then value.iso8601
+      when Symbol then value.to_s
+      else
+        value.respond_to?(:to_h) && !value.is_a?(Struct) ? value.to_h : value
+      end
+    end
+  end
+
+  module Schema
+    module_function
+    def for(type, options = {})
+      schema =
+        if type.is_a?(Array)
+          non_nil = type.reject { |item| item == NilClass }
+          non_nil.length == 1 ? self.for(non_nil.first) : { anyOf: non_nil.map { |item| self.for(item) } }
+        elsif type.is_a?(Hash) && type.key?(:array) then { type: "array", items: self.for(type[:array]) }
+        elsif type.is_a?(Class) && type <= Model then { "$ref": "#/components/schemas/#{type.name.split("::").last}" }
+        else
+          { String => { type: "string" }, Integer => { type: "integer" }, Float => { type: "number" },
+            Numeric => { type: "number" }, TrueClass => { type: "boolean" }, FalseClass => { type: "boolean" },
+            Array => { type: "array", items: {} }, Hash => { type: "object" },
+            Date => { type: "string", format: "date" }, Time => { type: "string", format: "date-time" } }[type] || {}
+        end
+      schema.merge(options.slice(:title, :description, :minimum, :maximum, :min_length, :max_length, :pattern, :enum).compact)
+    end
+  end
+end

data/lib/rubst_api/openapi.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module RubstApi
+  module OpenAPI
+    module_function
+
+    def generate(app)
+      schemas = {}
+      security_schemes = {}
+      paths = {}
+      app.routes.select(&:include_in_schema).each do |route|
+        operation = {
+          tags: route.tags.empty? ? nil : route.tags,
+          summary: route.summary || humanize(route.name || route.unique_id),
+          description: route.description,
+          operationId: route.unique_id,
+          deprecated: route.deprecated ? true : nil,
+          parameters: parameters_for(route, schemas),
+          responses: responses_for(route, schemas)
+        }.compact
+        security = security_for(route, security_schemes)
+        operation[:security] = security unless security.empty?
+        body = request_body_for(route, schemas)
+        operation[:requestBody] = body if body
+        route.methods.each do |method|
+          (paths[route.path] ||= {})[method.downcase.to_sym] = operation
+        end
+      end
+      {
+        openapi: app.openapi_version,
+        info: { title: app.title, version: app.version, description: app.description }.compact,
+        servers: app.servers.empty? ? nil : app.servers,
+        paths:,
+        components: {
+          schemas: schemas.empty? ? nil : schemas,
+          securitySchemes: security_schemes.empty? ? nil : security_schemes
+        }.compact,
+        tags: app.openapi_tags.empty? ? nil : app.openapi_tags
+      }.compact
+    end
+
+    def security_for(route, schemes)
+      (route.dependencies + route.params.values.grep(Dependency)).filter_map do |dependency|
+        callable = dependency.callable
+        next unless callable.respond_to?(:openapi_scheme)
+        name = callable.scheme_name
+        schemes[name] ||= callable.openapi_scheme
+        { name => dependency.is_a?(SecurityDependency) ? dependency.scopes : [] }
+      end
+    end
+
+    def parameters_for(route, schemas)
+      route.params.filter_map do |name, param|
+        next if param.is_a?(Dependency)
+        next if param.location == :body || param.location == :form || param.location == :file || !param.include_in_schema
+        collect_schema(param.type, schemas)
+        {
+          name: param.name_for(name), in: param.location.to_s, required: param.required?,
+          description: param.description, deprecated: param.deprecated,
+          schema: Schema.for(param.type, param.constraints)
+        }.compact
+      end
+    end
+
+    def request_body_for(route, schemas)
+      body_params = route.params.select { |_, param| param.is_a?(Param) && %i[body form file].include?(param.location) }
+      return if body_params.empty?
+      body_params.each_value { |param| collect_schema(param.type, schemas) }
+      media_type = body_params.values.any? { |param| param.location == :file } ? "multipart/form-data" :
+                   body_params.values.any? { |param| param.location == :form } ? "application/x-www-form-urlencoded" : "application/json"
+      schema = if body_params.length == 1
+                 Schema.for(body_params.values.first.type)
+               else
+                 { type: "object", properties: body_params.to_h { |name, param| [name, Schema.for(param.type)] },
+                   required: body_params.select { |_, param| param.required? }.keys }
+               end
+      { required: body_params.values.any?(&:required?), content: { media_type => { schema: } } }
+    end
+
+    def responses_for(route, schemas)
+      schema = route.response_model ? Schema.for(route.response_model) : {}
+      collect_schema(route.response_model, schemas) if route.response_model
+      output = { route.status_code.to_s => { description: status_description(route.status_code),
+                                             content: { "application/json" => { schema: } } } }
+      output["422"] = { description: "Validation Error", content: { "application/json" => {
+        schema: { "$ref": "#/components/schemas/HTTPValidationError" }
+      } } } unless route.params.empty?
+      route.responses.each { |code, definition| output[code.to_s] = definition }
+      output
+    end
+
+    def collect_schema(type, schemas)
+      if type.is_a?(Class) && type <= Model
+        schemas[type.name.split("::").last] ||= type.json_schema
+        type.fields.each_value { |field| collect_schema(field.type, schemas) }
+      elsif type.is_a?(Array)
+        type.each { |item| collect_schema(item, schemas) }
+      elsif type.is_a?(Hash) && type[:array]
+        collect_schema(type[:array], schemas)
+      end
+      schemas["ValidationError"] ||= {
+        type: "object", properties: {
+          loc: { type: "array", items: { anyOf: [{ type: "string" }, { type: "integer" }] } },
+          msg: { type: "string" }, type: { type: "string" }
+        }, required: %w[loc msg type]
+      }
+      schemas["HTTPValidationError"] ||= {
+        type: "object", properties: { detail: { type: "array", items: { "$ref": "#/components/schemas/ValidationError" } } }
+      }
+    end
+
+    def status_description(code)
+      { 200 => "Successful Response", 201 => "Successful Response", 202 => "Successful Response",
+        204 => "Successful Response", 301 => "Redirect Response", 307 => "Redirect Response" }[code] || "Response"
+    end
+    def humanize(value) = value.to_s.tr("_", " ").split.map(&:capitalize).join(" ")
+  end
+end

data/lib/rubst_api/params.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RubstApi
+  UNDEFINED = Object.new.freeze
+
+  class Param
+    attr_reader :location, :type, :default, :alias_name, :title, :description,
+                :examples, :deprecated, :include_in_schema, :constraints
+
+    def initialize(location, type: String, default: UNDEFINED, required: nil,
+                   alias_name: nil, alias: nil, title: nil, description: nil,
+                   examples: nil, deprecated: false, include_in_schema: true, **constraints)
+      @location, @type, @default = location, type, default
+      @required = required.nil? ? default.equal?(UNDEFINED) : required
+      @alias_name = alias_name || binding.local_variable_get(:alias)
+      @title, @description, @examples = title, description, examples
+      @deprecated, @include_in_schema = deprecated, include_in_schema
+      @constraints = constraints
+    end
+
+    def required? = @required
+    def name_for(name) = (alias_name || name).to_s
+  end
+
+  def self.Query(...) = RubstApi.Query(...)
+  def self.Path(...) = RubstApi.Path(...)
+  def self.Header(...) = RubstApi.Header(...)
+  def self.Cookie(...) = RubstApi.Cookie(...)
+  def self.Body(...) = RubstApi.Body(...)
+  def self.Form(...) = RubstApi.Form(...)
+  def self.File(...) = RubstApi.File(...)
+
+  class UploadFile
+    attr_reader :filename, :content_type, :headers, :io
+    def initialize(filename:, io:, content_type: "application/octet-stream", headers: {})
+      @filename, @io, @content_type, @headers = filename, io, content_type, headers
+    end
+    def read(...) = io.read(...)
+    def rewind = io.rewind
+    def close = io.close
+    def size = io.size
+  end
+end

data/lib/rubst_api/responses.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "json"
+
+module RubstApi
+  class Response
+    attr_accessor :status_code, :body
+    attr_reader :headers, :media_type
+    def initialize(content = nil, status_code: 200, headers: {}, media_type: "text/plain; charset=utf-8")
+      @body, @status_code, @headers, @media_type = render(content), status_code, Headers.new(headers), media_type
+      @headers["content-type"] ||= media_type
+    end
+    def render(content) = content.nil? ? "" : content.to_s
+    def set_cookie(key, value, max_age: nil, expires: nil, path: "/", domain: nil, secure: false, httponly: false, samesite: "lax")
+      parts = ["#{key}=#{value}", ("Max-Age=#{max_age}" if max_age), ("Expires=#{expires.httpdate}" if expires),
+               ("Path=#{path}" if path), ("Domain=#{domain}" if domain), ("Secure" if secure),
+               ("HttpOnly" if httponly), ("SameSite=#{samesite.to_s.capitalize}" if samesite)].compact
+      headers["set-cookie"] = parts.join("; ")
+    end
+    def delete_cookie(key, **options) = set_cookie(key, "", max_age: 0, expires: Time.at(0), **options)
+    def finish
+      payload = Array(body)
+      headers["content-length"] ||= payload.sum(&:bytesize).to_s
+      [status_code, headers.to_h, payload]
+    end
+  end
+
+  class JSONResponse < Response
+    def initialize(content = nil, **options)
+      super(content, media_type: "application/json", **options)
+    end
+    def render(content) = JSON.generate(Serializer.dump(content))
+  end
+
+  class HTMLResponse < Response
+    def initialize(content = nil, **options) = super(content, media_type: "text/html; charset=utf-8", **options)
+  end
+  class PlainTextResponse < Response; end
+  class RedirectResponse < Response
+    def initialize(url, status_code: 307, headers: {}, **)
+      super("", status_code:, headers: headers.merge("location" => url))
+    end
+  end
+  class StreamingResponse < Response
+    def initialize(content, **options)
+      super("", **options)
+      @body = content.respond_to?(:each) ? content : [content]
+    end
+    def finish = [status_code, headers.to_h, body]
+  end
+  class FileResponse < StreamingResponse
+    def initialize(path, filename: nil, media_type: "application/octet-stream", **options)
+      headers = options.delete(:headers) || {}
+      headers["content-disposition"] = %(attachment; filename="#{filename}") if filename
+      super(File.open(path, "rb"), media_type:, headers:, **options)
+    end
+  end
+  ORJSONResponse = JSONResponse
+  UJSONResponse = JSONResponse
+end

data/lib/rubst_api/routing.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RubstApi
+  class Route
+    attr_reader :path, :methods, :endpoint, :params, :response_model, :status_code,
+                :tags, :summary, :description, :operation_id, :deprecated,
+                :include_in_schema, :responses, :dependencies, :name
+
+    def initialize(path, endpoint:, methods:, params: {}, response_model: nil, status_code: 200,
+                   tags: [], summary: nil, description: nil, operation_id: nil, deprecated: false,
+                   include_in_schema: true, responses: {}, dependencies: [], name: nil, **)
+      @path, @endpoint, @methods, @params = normalize_path(path), endpoint, Array(methods).map { |m| m.to_s.upcase }, params
+      @response_model, @status_code, @tags = response_model, status_code, tags
+      @summary, @description, @operation_id = summary, description, operation_id
+      @deprecated, @include_in_schema, @responses = deprecated, include_in_schema, responses
+      @dependencies, @name = dependencies, name
+      @regexp, @path_names = compile(@path)
+    end
+
+    def match(request_path)
+      match = @regexp.match(request_path)
+      match&.named_captures || nil
+    end
+
+    def allowed?(method) = methods.include?(method) || (method == "HEAD" && methods.include?("GET"))
+
+    def unique_id
+      operation_id || "#{name || endpoint_name}_#{path.gsub(/\W+/, "_")}_#{methods.first.downcase}".gsub(/\A_|_\z/, "")
+    end
+
+    private
+
+    def normalize_path(path) = path.start_with?("/") ? path : "/#{path}"
+    def endpoint_name = endpoint.respond_to?(:name) && endpoint.name ? endpoint.name : "operation"
+    def compile(path)
+      names = path.scan(/\{([a-zA-Z_]\w*)\}/).flatten
+      source = Regexp.escape(path).gsub(/\\\{([a-zA-Z_]\w*)\\\}/, '(?<\1>[^/]+)')
+      [Regexp.new("\\A#{source}/?\\z"), names]
+    end
+  end
+
+  class APIRouter
+    HTTP_METHODS = %i[get post put patch delete options head trace].freeze
+    attr_reader :routes, :prefix, :tags, :dependencies
+
+    def initialize(prefix: "", tags: [], dependencies: [], **defaults)
+      @prefix, @tags, @dependencies, @defaults = prefix, tags, dependencies, defaults
+      @routes = []
+    end
+
+    HTTP_METHODS.each do |method|
+      define_method(method) do |path, endpoint = nil, **options, &block|
+        add_api_route(path, endpoint || block, methods: [method], **options)
+      end
+    end
+
+    def api_route(path, methods: ["GET"], **options, &block)
+      add_api_route(path, block, methods:, **options)
+    end
+
+    def add_api_route(path, endpoint = nil, methods: ["GET"], **options, &block)
+      callable = endpoint || block
+      raise ArgumentError, "an endpoint block or callable is required" unless callable.respond_to?(:call)
+      route = Route.new("#{prefix}#{path}", endpoint: callable, methods:,
+                        tags: tags + Array(options.delete(:tags)),
+                        dependencies: dependencies + Array(options.delete(:dependencies)),
+                        **@defaults, **options)
+      routes << route
+      route
+    end
+
+    def include_router(router, prefix: "", tags: [], dependencies: [])
+      router.routes.each do |route|
+        routes << Route.new("#{prefix}#{route.path}", endpoint: route.endpoint, methods: route.methods,
+                            params: route.params, response_model: route.response_model,
+                            status_code: route.status_code, tags: tags + route.tags,
+                            summary: route.summary, description: route.description,
+                            operation_id: route.operation_id, deprecated: route.deprecated,
+                            include_in_schema: route.include_in_schema, responses: route.responses,
+                            dependencies: dependencies + route.dependencies, name: route.name)
+      end
+      self
+    end
+
+    def websocket(path, endpoint = nil, **options, &block)
+      add_api_route(path, endpoint || block, methods: ["WEBSOCKET"], include_in_schema: false, **options)
+    end
+  end
+end

data/lib/rubst_api/security.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "base64"
+
+module RubstApi
+  module Security
+    HTTPAuthorizationCredentials = Data.define(:scheme, :credentials)
+    HTTPBasicCredentials = Data.define(:username, :password)
+    SecurityScopes = Data.define(:scopes) do
+      def scope_str = scopes.join(" ")
+    end
+
+    class Base
+      attr_reader :scheme_name, :description, :auto_error
+      def initialize(scheme_name: nil, description: nil, auto_error: true)
+        @scheme_name = scheme_name || self.class.name.split("::").last
+        @description, @auto_error = description, auto_error
+      end
+      def fail_auth(detail = "Not authenticated")
+        raise HTTPException.new(status_code: 401, detail:, headers: { "WWW-Authenticate" => scheme_name })
+      end
+    end
+
+    class HTTPBearer < Base
+      def call(request:)
+        scheme, credentials = request.headers["authorization"]&.split(" ", 2)
+        return fail_auth unless scheme&.casecmp?("Bearer") && credentials
+        HTTPAuthorizationCredentials.new(scheme, credentials)
+      rescue HTTPException
+        raise if auto_error
+        nil
+      end
+      def openapi_scheme = { type: "http", scheme: "bearer", description: description }.compact
+    end
+
+    class HTTPBasic < Base
+      def call(request:)
+        scheme, credentials = request.headers["authorization"]&.split(" ", 2)
+        return fail_auth unless scheme&.casecmp?("Basic") && credentials
+        username, password = Base64.strict_decode64(credentials).split(":", 2)
+        HTTPBasicCredentials.new(username, password)
+      rescue StandardError
+        raise if auto_error
+        nil
+      end
+      def openapi_scheme = { type: "http", scheme: "basic", description: description }.compact
+    end
+
+    class APIKeyHeader < Base
+      def initialize(name:, **options) = (@name = name; super(**options))
+      def call(request:)
+        request.headers[@name] || (auto_error ? fail_auth("Not authenticated") : nil)
+      end
+      def openapi_scheme = { type: "apiKey", in: "header", name: @name, description: description }.compact
+    end
+
+    class APIKeyQuery < Base
+      def initialize(name:, **options) = (@name = name; super(**options))
+      def call(request:)
+        request.query_params[@name] || (auto_error ? fail_auth("Not authenticated") : nil)
+      end
+      def openapi_scheme = { type: "apiKey", in: "query", name: @name, description: description }.compact
+    end
+
+    class APIKeyCookie < Base
+      def initialize(name:, **options) = (@name = name; super(**options))
+      def call(request:)
+        request.cookies[@name] || (auto_error ? fail_auth("Not authenticated") : nil)
+      end
+      def openapi_scheme = { type: "apiKey", in: "cookie", name: @name, description: description }.compact
+    end
+
+    class OAuth2PasswordBearer < HTTPBearer
+      attr_reader :token_url, :scopes
+      def initialize(token_url:, scopes: {}, **options)
+        @token_url, @scopes = token_url, scopes
+        super(**options)
+      end
+      def call(request:) = super.credentials
+      def openapi_scheme
+        { type: "oauth2", flows: { password: { tokenUrl: token_url, scopes: scopes } }, description: description }.compact
+      end
+    end
+  end
+end

data/lib/rubst_api/sse.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RubstApi
+  ServerSentEvent = Data.define(:data, :event, :id, :retry, :comment) do
+    def encode
+      lines = []
+      lines << ": #{comment}" if comment
+      lines << "id: #{id}" if id
+      lines << "event: #{event}" if event
+      lines << "retry: #{self.retry}" if self.retry
+      payload = data.is_a?(String) ? data : JSON.generate(Serializer.dump(data))
+      payload.each_line { |line| lines << "data: #{line.chomp}" }
+      "#{lines.join("\n")}\n\n"
+    end
+  end
+
+  class EventSourceResponse < StreamingResponse
+    def initialize(content, ping: 15, **options)
+      stream = Enumerator.new do |output|
+        content.each do |event|
+          event = ServerSentEvent.new(event, nil, nil, nil, nil) unless event.is_a?(ServerSentEvent)
+          output << event.encode
+        end
+      end
+      super(stream, media_type: "text/event-stream", headers: { "cache-control" => "no-cache" }, **options)
+    end
+  end
+end

data/lib/rubst_api/static_files.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RubstApi
+  class StaticFiles
+    MIME_TYPES = {
+      ".html" => "text/html; charset=utf-8", ".css" => "text/css; charset=utf-8",
+      ".js" => "application/javascript", ".json" => "application/json",
+      ".png" => "image/png", ".jpg" => "image/jpeg", ".jpeg" => "image/jpeg",
+      ".svg" => "image/svg+xml", ".txt" => "text/plain; charset=utf-8"
+    }.freeze
+
+    def initialize(directory:, html: false, check_dir: true)
+      @directory, @html = File.expand_path(directory), html
+      raise ArgumentError, "Directory does not exist: #{directory}" if check_dir && !Dir.exist?(@directory)
+    end
+
+    def call(env)
+      relative = URI.decode_www_form_component(env.fetch("PATH_INFO", "/")).sub(%r{\A/+}, "")
+      path = File.expand_path(relative, @directory)
+      return not_found unless path == @directory || path.start_with?("#{@directory}#{File::SEPARATOR}")
+      path = File.join(path, "index.html") if @html && File.directory?(path)
+      return not_found unless File.file?(path)
+      FileResponse.new(path, media_type: MIME_TYPES.fetch(File.extname(path).downcase, "application/octet-stream")).finish
+    end
+
+    private
+
+    def not_found = PlainTextResponse.new("Not Found", status_code: 404).finish
+  end
+end

data/lib/rubst_api/status.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RubstApi
+  module Status
+    HTTP_100_CONTINUE = 100
+    HTTP_200_OK = 200
+    HTTP_201_CREATED = 201
+    HTTP_202_ACCEPTED = 202
+    HTTP_204_NO_CONTENT = 204
+    HTTP_301_MOVED_PERMANENTLY = 301
+    HTTP_302_FOUND = 302
+    HTTP_304_NOT_MODIFIED = 304
+    HTTP_307_TEMPORARY_REDIRECT = 307
+    HTTP_308_PERMANENT_REDIRECT = 308
+    HTTP_400_BAD_REQUEST = 400
+    HTTP_401_UNAUTHORIZED = 401
+    HTTP_403_FORBIDDEN = 403
+    HTTP_404_NOT_FOUND = 404
+    HTTP_405_METHOD_NOT_ALLOWED = 405
+    HTTP_409_CONFLICT = 409
+    HTTP_415_UNSUPPORTED_MEDIA_TYPE = 415
+    HTTP_422_UNPROCESSABLE_ENTITY = 422
+    HTTP_429_TOO_MANY_REQUESTS = 429
+    HTTP_500_INTERNAL_SERVER_ERROR = 500
+    HTTP_502_BAD_GATEWAY = 502
+    HTTP_503_SERVICE_UNAVAILABLE = 503
+  end
+end