fastrb 0.1.0

data/lib/rubyapi/param_converters.rb

@@ -0,0 +1,58 @@
+require "securerandom"
+require "time"
+require "date"
+require "bigdecimal"
+
+module RubyAPI
+  Boolean = Class.new unless defined?(Boolean)
+  UUID = Class.new unless defined?(UUID)
+  Decimal = BigDecimal unless defined?(Decimal)
+
+  class ConversionError < StandardError
+    def initialize(param_name, type_name)
+      super("#{param_name} must be #{type_name}")
+    end
+  end
+
+  module ParamConverters
+    CONVERTERS = {
+      String   => ->(v) { v.to_s },
+      Integer  => ->(v) { Integer(v) },
+      Float    => ->(v) { Float(v) },
+      Boolean  => ->(v) {
+        case v.to_s.downcase
+        when "true", "1", "yes" then true
+        when "false", "0", "no", "nil" then false
+        else raise ArgumentError
+        end
+      },
+      Date     => ->(v) { Date.parse(v) },
+      Time     => ->(v) { Time.parse(v) },
+      DateTime => ->(v) { DateTime.parse(v) },
+      Array    => ->(v) {
+        return v if v.is_a?(Array)
+        JSON.parse(v)
+      },
+      Hash     => ->(v) {
+        return v if v.is_a?(Hash)
+        JSON.parse(v)
+      },
+      UUID     => ->(v) {
+        uuid = v.to_s
+        raise ArgumentError unless uuid.match?(/\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i)
+        uuid
+      },
+      Decimal  => ->(v) { BigDecimal(v.to_s) },
+      Symbol   => ->(v) { v.to_sym }
+    }.freeze
+
+    def self.convert(value, type)
+      converter = CONVERTERS[type]
+      return value.to_s unless converter
+      converter.call(value)
+    rescue ArgumentError, TypeError, JSON::ParserError
+      type_name = type.respond_to?(:name) ? type.name : type.to_s
+      raise ConversionError.new(value.to_s, type_name)
+    end
+  end
+end

data/lib/rubyapi/plugin.rb

@@ -0,0 +1,37 @@
+module RubyAPI
+  class Plugin
+    def self.inherited(subclass)
+      RubyAPI::PluginRegistry.register(subclass)
+    end
+
+    def self.on_load(app); end
+    def self.register_routes(app); end
+    def self.register_cli(commands); end
+    def self.plugin_name
+      name.split("::").last
+    end
+
+    def self.options
+      @options ||= {}
+    end
+
+    def self.option(key, value = nil)
+      @options ||= {}
+      @options[key] = value
+    end
+  end
+
+  class PluginRegistry
+    def self.plugins
+      @plugins ||= []
+    end
+
+    def self.register(klass)
+      plugins << klass unless plugins.include?(klass)
+    end
+
+    def self.find(name)
+      plugins.find { |p| p.plugin_name == name.to_s || p == name }
+    end
+  end
+end

data/lib/rubyapi/plugins/auth.rb

@@ -0,0 +1,20 @@
+module RubyAPI
+  module Plugins
+    class Auth < Plugin
+      option :unauthorized_status, 401
+      option :unauthorized_body, { error: "Unauthorized" }
+
+      def self.on_load(app)
+        app.before do |ctx|
+          payload = ctx.get(:jwt_payload)
+          unless payload
+            status = options[:unauthorized_status]
+            body = options[:unauthorized_body]
+            ctx.response_status = status
+            ctx.response_body = body
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubyapi/plugins/cache.rb

@@ -0,0 +1,41 @@
+module RubyAPI
+  module Plugins
+    class Cache < Plugin
+      option :store, {}
+      option :default_ttl, 3600
+
+      def self.store
+        options[:store]
+      end
+
+      def self.get(key)
+        entry = store[key]
+        return nil unless entry
+        return nil if Time.now > entry[:expires_at]
+        entry[:value]
+      end
+
+      def self.set(key, value, ttl: nil)
+        ttl ||= options[:default_ttl]
+        store[key] = {
+          value: value,
+          expires_at: Time.now + ttl
+        }
+      end
+
+      def self.delete(key)
+        store.delete(key)
+      end
+
+      def self.clear
+        store.clear
+      end
+
+      def self.on_load(app)
+        app.before do |ctx|
+          ctx.set(:cache, self)
+        end
+      end
+    end
+  end
+end

data/lib/rubyapi/plugins/cors.rb

@@ -0,0 +1,35 @@
+module RubyAPI
+  module Plugins
+    class CORS < Plugin
+      option :origins, ["*"]
+      option :methods, ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"]
+      option :headers, ["Content-Type", "Authorization"]
+      option :allow_credentials, false
+      option :max_age, 86400
+
+      def self.on_load(app)
+        allowed = options[:origins]
+        methods = options[:methods].join(", ")
+        headers = options[:headers].join(", ")
+        credentials = options[:allow_credentials]
+        max_age = options[:max_age]
+
+        app.before do |ctx|
+          origin = ctx.request.get_header("HTTP_ORIGIN")
+          next unless allowed.include?("*") || allowed.include?(origin)
+
+          ctx.response_headers["access-control-allow-origin"] = origin || "*"
+          ctx.response_headers["access-control-allow-methods"] = methods
+          ctx.response_headers["access-control-allow-headers"] = headers
+          ctx.response_headers["access-control-allow-credentials"] = credentials.to_s if credentials
+          ctx.response_headers["access-control-max-age"] = max_age.to_s
+
+          if ctx.request.request_method == "OPTIONS"
+            ctx.response_status = 204
+            ctx.response_body = ""
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubyapi/plugins/jwt.rb

@@ -0,0 +1,42 @@
+require "json"
+require "base64"
+require "openssl"
+require "jwt"
+
+module RubyAPI
+  module Plugins
+    class JWT < Plugin
+      option :secret, "default_secret"
+      option :algorithm, "HS256"
+      option :header, "Authorization"
+      option :prefix, "Bearer "
+
+      def self.decode(token)
+        secret = options[:secret]
+        algorithm = options[:algorithm]
+        payload, _header = ::JWT.decode(token, secret, true, algorithm: algorithm)
+        payload
+      rescue StandardError
+        nil
+      end
+
+      def self.encode(payload)
+        secret = options[:secret]
+        algorithm = options[:algorithm]
+        ::JWT.encode(payload, secret, algorithm)
+      end
+
+      def self.on_load(app)
+        app.before do |ctx|
+          header_value = ctx.request.get_header("HTTP_AUTHORIZATION")
+          next unless header_value
+
+          prefix = options[:prefix]
+          token = header_value.sub(/\A#{Regexp.escape(prefix)}/, "")
+          payload = decode(token)
+          ctx.set(:jwt_payload, payload) if payload
+        end
+      end
+    end
+  end
+end

data/lib/rubyapi/router.rb

@@ -0,0 +1,99 @@
+module RubyAPI
+  class Router
+    attr_reader :routes, :current_prefix
+
+    def initialize
+      @routes = []
+      @trie = TrieNode.new
+      @current_prefix = ""
+    end
+
+    def add_route(method, path, **opts, &block)
+      full_path = @current_prefix + path
+      pattern = compile_pattern(full_path)
+      param_names = extract_param_names(full_path)
+
+      route = {
+        method: method,
+        path: full_path,
+        pattern: pattern,
+        param_names: param_names,
+        block: block,
+        params: opts[:params] || {},
+        body: opts[:body],
+        injected_deps: opts[:inject] || [],
+        dependency_checks: opts[:depends] || []
+      }
+
+      @routes << route
+      @trie.insert(full_path, route)
+      route
+    end
+
+    def push_prefix(prefix)
+      @current_prefix = @current_prefix + prefix
+    end
+
+    def pop_prefix(prefix)
+      @current_prefix = @current_prefix[0...-prefix.length]
+    end
+
+    def find(method, path)
+      route = @trie.search(path)
+      return nil unless route
+      return nil unless route[:method].to_s == method.to_s
+      route
+    end
+
+    private
+
+    def compile_pattern(path)
+      segments = path.split("/")
+      pattern_parts = segments.map do |seg|
+        if seg.start_with?(":")
+          "([^/]+)"
+        elsif seg == "*"
+          "(.+)"
+        else
+          Regexp.escape(seg)
+        end
+      end
+      /\A#{pattern_parts.join("/")}\z/
+    end
+
+    def extract_param_names(path)
+      path.split("/").select { |s| s.start_with?(":") }.map { |s| s[1..].to_sym }
+    end
+  end
+
+  class TrieNode
+    attr_accessor :children, :route
+
+    def initialize
+      @children = {}
+      @route = nil
+    end
+
+    def insert(path, route)
+      segments = path.split("/").reject(&:empty?)
+      node = self
+      segments.each do |seg|
+        child_key = seg.start_with?(":") ? :__param__ : seg
+        node.children[child_key] ||= TrieNode.new
+        node = node.children[child_key]
+      end
+      node.route = route
+    end
+
+    def search(path)
+      segments = path.split("/").reject(&:empty?)
+      node = self
+      segments.each do |seg|
+        child = node.children[seg] || node.children[:__param__]
+        return nil unless child
+        node = child
+      end
+      node.route
+    end
+  end
+end

data/lib/rubyapi/schema.rb

@@ -0,0 +1,46 @@
+module RubyAPI
+  class Schema
+    class ValidationError < StandardError
+      attr_reader :errors
+
+      def initialize(errors)
+        @errors = errors
+        super("Validation failed: #{errors.map { |k, v| "#{k}: #{v}" }.join(', ')}")
+      end
+    end
+
+    def self.field(name, type: String)
+      @fields ||= {}
+      @fields[name] = type
+    end
+
+    def self.fields
+      @fields || {}
+    end
+
+    def self.inherited(subclass)
+      subclass.instance_variable_set(:@fields, (@fields || {}).dup)
+    end
+
+    def self.validate(data)
+      errors = {}
+      result = {}
+
+      fields.each do |name, type|
+        value = data.is_a?(Hash) ? (data[name.to_s] || data[name]) : nil
+        if value.nil?
+          errors[name] = "is required"
+          next
+        end
+        begin
+          result[name] = ParamConverters.convert(value, type)
+        rescue ConversionError => e
+          errors[name] = e.message
+        end
+      end
+
+      raise ValidationError.new(errors) if errors.any?
+      result
+    end
+  end
+end

data/lib/rubyapi/serializer.rb

@@ -0,0 +1,25 @@
+module RubyAPI
+  module Serializer
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def field(name, type: String)
+        @fields ||= {}
+        @fields[name] = type
+      end
+
+      def fields
+        @fields || {}
+      end
+    end
+
+    def serialize(object)
+      self.class.fields.each_with_object({}) do |(name, type), hash|
+        value = object.send(name)
+        hash[name] = value
+      end
+    end
+  end
+end

data/lib/rubyapi/session.rb

@@ -0,0 +1,62 @@
+require "rack"
+require "json"
+require "base64"
+require "openssl"
+
+module RubyAPI
+  class Session
+    SESSION_COOKIE = "_rubyapi_session".freeze
+
+    def initialize(request, secret_key: nil)
+      @request = request
+      @secret_key = secret_key || "rubyapi_default_secret"
+      @data = load_session
+    end
+
+    def [](key)
+      @data[key.to_s]
+    end
+
+    def []=(key, value)
+      @data[key.to_s] = value
+    end
+
+    def to_hash
+      @data.dup
+    end
+
+    def serialize
+      json = JSON.generate(@data)
+      encode(json)
+    end
+
+    private
+
+    def load_session
+      cookie_value = @request.cookies[SESSION_COOKIE]
+      return {} unless cookie_value
+      json = decode(cookie_value)
+      JSON.parse(json)
+    rescue StandardError
+      {}
+    end
+
+    def encode(data)
+      encoded = Base64.strict_encode64(data)
+      signature = sign(encoded)
+      "#{encoded}.#{signature}"
+    end
+
+    def decode(data)
+      encoded, signature = data.to_s.split(".", 2)
+      return nil unless encoded && signature
+      expected = sign(encoded)
+      return nil unless Rack::Utils.secure_compare(signature, expected)
+      Base64.strict_decode64(encoded)
+    end
+
+    def sign(data)
+      OpenSSL::HMAC.hexdigest("SHA256", @secret_key, data)
+    end
+  end
+end

data/lib/rubyapi/sse.rb

@@ -0,0 +1,30 @@
+module RubyAPI
+  class SSE
+    attr_reader :io
+
+    def initialize(io)
+      @io = io
+      @closed = false
+    end
+
+    def send(event:, data:, id: nil)
+      return if @closed
+      @io.write("event: #{event}\n") if event
+      @io.write("id: #{id}\n") if id
+      data.to_s.each_line do |line|
+        @io.write("data: #{line}")
+      end
+      @io.write("\n")
+      @io.flush
+    end
+
+    def close
+      @closed = true
+      @io.close if @io.respond_to?(:close) && !@io.closed?
+    end
+
+    def closed?
+      @closed
+    end
+  end
+end

data/lib/rubyapi/streaming.rb

@@ -0,0 +1,58 @@
+require "securerandom"
+
+module RubyAPI
+  class StreamingBody
+    include Enumerable
+
+    def initialize
+      @buffer = Queue.new
+      @closed = false
+    end
+
+    def write(data)
+      @buffer << data.to_s
+    end
+
+    def close
+      @closed = true
+      @buffer << nil
+    end
+
+    def each
+      loop do
+        data = @buffer.pop
+        break if data.nil?
+        yield data
+      end
+    end
+
+    def closed?
+      @closed
+    end
+  end
+
+  class SSEStream
+    attr_reader :body
+
+    def initialize
+      @body = StreamingBody.new
+      @sse = SSE.new(@body)
+      @closed = false
+    end
+
+    def send_event(event:, data:, id: nil)
+      return if @closed
+      @sse.send(event: event, data: data, id: id)
+    end
+
+    def close
+      @closed = true
+      @sse.close
+      @body.close
+    end
+
+    def closed?
+      @closed
+    end
+  end
+end

data/lib/rubyapi/version.rb

@@ -0,0 +1,3 @@
+module RubyAPI
+  VERSION = "0.1.0"
+end

data/lib/rubyapi/websocket.rb

@@ -0,0 +1,64 @@
+module RubyAPI
+  class WebSocket
+    attr_reader :env, :path
+
+    def initialize(env, &handler)
+      @env = env
+      @handler = handler
+      @messages = Queue.new
+      @closed = false
+      @on_message = nil
+      @on_close = nil
+      @on_open = nil
+    end
+
+    def on_open(&block)
+      @on_open = block
+    end
+
+    def on_message(&block)
+      @on_message = block
+    end
+
+    def on_close(&block)
+      @on_close = block
+    end
+
+    def send(data)
+      @messages << { type: :send, data: data }
+    end
+
+    def close(code = 1000, reason = "")
+      @messages << { type: :close, code: code, reason: reason }
+      @closed = true
+    end
+
+    def closed?
+      @closed
+    end
+
+    def receive
+      msg = @messages.pop
+      msg
+    end
+
+    def hijack?
+      true
+    end
+
+    def process!
+      @on_open&.call(self)
+      @handler.call(self) if @handler
+    rescue => e
+      @on_close&.call(e) if @on_close
+    ensure
+      @on_close&.call(nil) unless @closed
+    end
+
+    def self.upgrade(env)
+      io = env["rack.hijack"]&.call
+      return nil unless io
+      io
+    end
+  end
+end