syntropy 0.31.0 → 0.33.0

data/lib/syntropy/db/schema.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Syntropy
+  module DB
+    class Schema
+      def initialize(module_loader: nil, schema_root: '_schema', &)
+        @migrations = {}
+        @module_loader = module_loader
+        @schema_root = schema_root
+        load_schema_from_modules if @module_loader
+        run_schema_block(&) if block_given?
+      end
+
+      def apply(connection_pool)
+        execute_migrations(connection_pool)
+      end
+
+      def current_version(connection_pool)
+        connection_pool.with_db do |db|
+          get_schema_version(db)
+        end
+      end
+
+      private
+
+      def load_schema_from_modules
+        modules = @module_loader.list(@schema_root)
+        modules.each do |name|
+          @migrations[File.basename(name)] = @module_loader.load(name)
+        end
+      end
+
+      class SchemaBlockRunner
+        def initialize(migrations, &)
+          @migrations = migrations
+          instance_eval(&)
+        end
+
+        def initial(&block)
+          @migrations['0000'] = block
+        end
+
+        def version(key, &block)
+          @migrations[key] = block
+        end
+      end
+
+      def run_schema_block(&)
+        SchemaBlockRunner.new(@migrations, &)
+      end
+
+      def execute_migrations(connection_pool)
+        connection_pool.with_db do |db|
+          current_version = get_schema_version(db)
+          migrations_keys = @migrations.keys.sort
+          migrations_keys.select { it > current_version } if current_version
+
+          migrations_keys.each do |key|
+            db.transaction do
+              @migrations[key].(db)
+              set_schema_version(db, key)
+              current_version = key
+            end
+          end
+
+          current_version
+        end
+      end
+
+      def get_schema_version(db)
+        db.execute <<~SQL
+          create table if not exists __syntropy_schema__(
+            k text primary key,
+            v text
+          );
+        SQL
+        db.query_single_splat <<~SQL
+          select v from __syntropy_schema__
+          where k = 'version'
+        SQL
+      end
+
+      def set_schema_version(db, version)
+        db.execute <<~SQL, v: version
+          insert into __syntropy_schema__ (k, v)
+          values ('version', :v)
+          on conflict(k) do update set v = :v
+        SQL
+      end
+    end
+  end
+end

data/lib/syntropy/db/store.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Syntropy
+  module DB
+    class Store
+      def initialize(connection_pool)
+        @connection_pool = connection_pool
+      end
+
+      def query(sql, *, **)
+        @connection_pool.with_db { it.query(sql, *, **) }
+      end
+
+      def query_single_row(sql, *, **)
+        @connection_pool.with_db { it.query_single(sql, *, **) }
+      end
+
+      def query_single_value(sql, *, **)
+        @connection_pool.with_db { it.query_single_splat(sql, *, **) }
+      end
+
+      def execute(sql, *, **)
+        @connection_pool.with_db { it.execute(sql, *, **) }
+      end
+
+      def transaction(&)
+        @connection_pool.with_db(&)
+      end
+    end
+  end
+end

data/lib/syntropy/http/io_extensions.rb

@@ -5,13 +5,13 @@ require 'syntropy/errors'
 module Syntropy
   module HTTP
     module ProtocolMethods
-      RE_REQUEST_LINE = /^([a-z]+)\s+([^\s]+)\s+HTTP\/([019\.]{1,3})/i
+      RE_REQUEST_LINE = /^(get|head|options|trace|put|delete|post|patch|connect)\s+([^\s]+)\s+HTTP\/([019\.]{1,3})/i
       RE_RESPONSE_LINE = /^HTTP\/1\.1\s+(\d{3})(\s+.+)?$/i
-      RE_HEADER_LINE = /^([a-z0-9-]+):\s+(.+)/i
+      RE_HEADER_LINE = /^([a-z0-9\-]+):\s+(.+)/i
 
       MAX_REQUEST_LINE_LEN = 1 << 14 # 16KB
       MAX_RESPONSE_LINE_LEN = 1 << 8 # 256
-      MAX_HEADER_LINE_LEN = 1 << 10 # 1KB
+      MAX_HEADER_LINE_LEN = 1 << 13 # 8KB
       MAX_CHUNK_SIZE_LEN = 16
 
       # @return [Hash] headers
@@ -27,8 +27,7 @@ module Syntropy
 
         headers = {
           ':method'   => m[1].downcase,
-          ':path'     => m[2],
-          ':protocol' => 'http/1.1'
+          ':path'     => m[2]
         }
 
         loop do
@@ -93,6 +92,21 @@ module Syntropy
         nil
       end
 
+      def http_skip_body(headers)
+        content_length = headers['content-length']
+        if content_length
+          return skip(content_length.to_i)
+        end
+
+        chunked_encoding = headers['transfer-encoding']&.downcase == 'chunked'
+        if chunked_encoding
+          while http_skip_cte_chunk
+          end
+        end
+
+        nil
+      end
+
       def http_read_body_chunk(headers)
         content_length = headers['content-length']
         if content_length
@@ -141,6 +155,20 @@ module Syntropy
 
         buffer ? (buffer << chunk) : chunk
       end
+
+      def http_skip_cte_chunk
+        chunk_size_str = read_line(MAX_CHUNK_SIZE_LEN)
+        return if !chunk_size_str
+
+        chunk_size = chunk_size_str.to_i(16)
+        if chunk_size == 0
+          read_line(0)
+          return nil
+        end
+
+        chunk = skip(chunk_size)
+        read_line(0)
+      end
     end
   end
 end

data/lib/syntropy/http/server_connection.rb

@@ -23,12 +23,11 @@ module Syntropy
 
         @done = nil
         @response_headers = nil
+        @response_cookies = nil
       end
 
       def run
         loop do
-          @done = nil
-          @response_headers = nil
           persist = serve_request
           break if !persist
         end
@@ -47,14 +46,21 @@ module Syntropy
       # object and handing it off to the app handler. Returns true if the
       # connection should be persisted.
       def serve_request
+        @done = nil
+        @response_headers = nil
+        @response_cookies = nil
         @closed = nil
-        headers = parse_headers
+        headers = @io.http_read_request_headers
         return false if !headers
 
         request = Syntropy::Request.new(headers, self)
 
         @app.call(request)
-        persist_connection?(headers)
+        persist = persist_connection?(headers)
+        if persist && !headers[':body-done-reading'] && (headers['content-length'] || headers['transfer-encoding'])
+          get_body(request)
+        end
+        persist
       rescue StandardError => e
         handle_error(request, e)
         false
@@ -126,13 +132,10 @@ module Syntropy
         @response_headers ? @response_headers.merge!(headers) : @response_headers = headers
       end
 
-      def set_cookie(*cookies)
-        existing_cookies = @response_headers && @response_headers['Set-Cookie']
-        if existing_cookies
-          @response_headers['Set-Cookie'] = existing_cookies + cookies
-        else
-          set_response_headers('Set-Cookie' => cookies)
-        end
+      DELETE_COOKIE = "; Expires=Thu, 01 Jan 1970 00:00:00 GMT; Path=/; Max-Age=0; HttpOnly"
+
+      def set_cookie(key, value)
+        (@response_cookies ||= {})[key] = value || DELETE_COOKIE
       end
 
       SEND_FLAGS = UM::MSG_NOSIGNAL | UM::MSG_WAITALL
@@ -148,6 +151,7 @@ module Syntropy
       # @param body [String] response body
       # @param headers
       def respond(request, body, headers)
+        add_set_cookie_headers if @response_cookies
         headers = @response_headers.merge(headers) if @response_headers
 
         formatted_headers = format_headers(headers, body)
@@ -264,57 +268,6 @@ module Syntropy
         return connection != 'close'
       end
 
-      def parse_headers
-        headers = get_request_line(MAX_REQUEST_LINE_LEN)
-        return nil if !headers
-
-        loop do
-          line = @io.read_line(MAX_HEADER_LINE_LEN)
-          break if line.nil? || line.empty?
-
-          m = line.match(RE_HEADER_LINE)
-          raise ProtocolError, "Invalid header: #{line[0..2047].inspect}" if !m
-
-          headers[m[1].downcase] = m[2]
-        end
-
-        headers
-      end
-
-      def get_request_line(buf)
-        line = @io.read_line(MAX_REQUEST_LINE_LEN)
-        return nil if !line
-
-        m = line.match(RE_REQUEST_LINE)
-        raise ProtocolError, 'Invalid request line' if !m
-
-        http_version = m[3]
-        raise UnsupportedHTTPVersionError, 'HTTP version not supported' if http_version != '1.1'
-
-        {
-          ':method'   => m[1].downcase,
-          ':path'     => m[2],
-          ':protocol' => 'http/1.1'
-        }
-      end
-
-      def read_chunk(headers, buffer)
-        chunk_size_str = @io.read_line(MAX_CHUNK_SIZE_LEN)
-        return nil if !chunk_size_str
-
-        chunk_size = chunk_size_str.to_i(16)
-        if chunk_size == 0
-          headers[':body-done-reading'] = true
-          @io.read_line(0)
-          return nil
-        end
-
-        chunk = @io.read(chunk_size)
-        @io.read_line(0)
-
-        buffer ? (buffer << chunk) : chunk
-      end
-
       INTERNAL_HEADER_REGEXP = /^:/
 
       # Formats response headers into an array. If empty_response is true(thy),
@@ -362,6 +315,12 @@ module Syntropy
           lines << "#{key}: #{value}\r\n"
         end
       end
+
+      def add_set_cookie_headers
+        @response_headers ||= {}
+        sc = (@response_headers['Set-Cookie'] ||= [])
+        @response_cookies.each { |k, v| sc << "#{k}=#{v}" }
+      end
     end
   end
 end

data/lib/syntropy/{module.rb → module_loader.rb}

@@ -27,8 +27,8 @@ module Syntropy
     # @param env [Hash] environment hash
     # @return [void]
     def initialize(env)
-      @root_dir = env[:root_dir]
       @env = env
+      @root_dir = env[:root_dir]
       @modules = {} # maps ref to module entry
       @fn_map = {} # maps filename to ref
     end
@@ -37,13 +37,28 @@ module Syntropy
     #
     # @param ref [String] module reference
     # @return [any] export value
-    def load(ref)
+    def load(ref, raise_on_missing: true)
       ref = "/#{ref}" if ref !~ /^\//
+      if !(entry = @modules[ref])
+        entry = load_module(ref, raise_on_missing:)
+        return if !entry
 
-      entry = (@modules[ref] ||= load_module(ref))
+        @modules[ref] = entry
+      end
       entry[:export_value]
     end
 
+    # Returns a list of modules found in the given relative path. The module
+    # references are returned as absolute paths (relative to the module loader
+    # root directory).
+    #
+    # @param dir [String] relative module directory
+    # @return [Array<String>] list of modules
+    def list(dir)
+      fns = Dir[File.join(@root_dir, dir, '*.rb')]
+      fns.map { it.match(/^#{@root_dir}\/(.+)\.rb$/)[1] }.sort
+    end
+
     # Invalidates a module by its filename, normally following a change to the
     # underlying file (in order to cause reloading of the module). The module
     # will be removed from the modules map, as well as modules dependending on
@@ -101,17 +116,23 @@ module Syntropy
     #
     # @param ref [String] module reference
     # @return [Hash] module entry
-    def load_module(ref)
+    def load_module(ref, raise_on_missing: true)
       ref = "/#{ref}" if ref !~ /^\//
       fn = File.expand_path(File.join(@root_dir, "#{ref}.rb"))
-      raise Syntropy::Error, "File not found #{fn}" if !File.file?(fn)
+      if !File.file?(fn)
+        raise Syntropy::Error, "File not found #{fn}" if raise_on_missing
+
+        return
+      end
 
       @fn_map[fn] = ref
       code = IO.read(fn)
       env = @env.merge(module_loader: self, ref: clean_ref(ref))
       mod = Syntropy::Module.load(env, code, fn)
       add_dependencies(ref, mod.__dependencies__)
-      export_value = transform_module_export_value(mod.__export_value__)
+      export_value = transform_module_export_value(
+        mod.__export_value__, fn, raise_on_missing:
+      )
 
       {
         fn: fn,
@@ -133,10 +154,10 @@ module Syntropy
     #
     # @param export_value [any] module's export value
     # @return [any] transformed value
-    def transform_module_export_value(export_value)
+    def transform_module_export_value(export_value, fn, raise_on_missing:)
       case export_value
       when nil
-        raise Syntropy::Error, 'No export found'
+        raise Syntropy::Error, "No export found in #{fn}" if raise_on_missing
       when String
         ->(req) { req.respond(export_value) }
       when Class
@@ -278,9 +299,28 @@ module Syntropy
     # environment is based on the module's env merged with the given parameters.
     #
     # @param env [Hash] environment
+    # @return [Syntropy::App]
     def app(**env)
       env = @env.merge(env)
       Syntropy::App.new(**env)
     end
+
+    # Returns a request handler that handles requests by calling the appropriate
+    # module method (e.g. get, post, etc.)
+    #
+    # @return [Proc]
+    def http_methods
+      ->(req) { route_by_http_method(req) }
+    end
+
+    # Handles the given request by calling the module method corresponding to
+    # the request's HTTP method. If no method is found, raises a
+    # method_not_allowed error.
+    def route_by_http_method(req)
+      sym = req.method.to_sym
+      raise Syntropy::Error.method_not_allowed if !respond_to?(sym)
+
+      send(sym, req)
+    end
   end
 end

data/lib/syntropy/request/request_info.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'uri'
-require 'escape_utils'
 
 module Syntropy
   module RequestInfoMethods
@@ -122,7 +121,7 @@ module Syntropy
         raise BadRequestError, 'Invalid cookie format' unless c.strip =~ COOKIE_RE
 
         key, value = Regexp.last_match[1..2]
-        h[key] = EscapeUtils.unescape_uri(value)
+        h[key] = URI.decode_www_form_component(value)
       end
     end
 
@@ -159,7 +158,7 @@ module Syntropy
 
     def auth_bearer_token
       auth = headers['authorization']
-      if (m = auth.match(/Bearer\s+([^\w]+)/))
+      if auth && (m = auth.match(/Bearer\s+([^\w]+)/))
         return m[1]
       end
 
@@ -248,7 +247,7 @@ module Syntropy
         v = Regexp.last_match(2)
         raise BadRequestError, 'Invalid parameter size' if v && v.size > MAX_PARAMETER_VALUE_SIZE
 
-        m[EscapeUtils.unescape_uri(k)] = v ? EscapeUtils.unescape_uri(v) : true
+        m[URI.decode_www_form_component(k)] = v ? URI.decode_www_form_component(v) : true
       end
     end
   end

data/lib/syntropy/request/response.rb

@@ -105,8 +105,8 @@ module Syntropy
       adapter.set_response_headers(headers)
     end
 
-    def set_cookie(*)
-      adapter.set_cookie(*)
+    def set_cookie(k, v)
+      adapter.set_cookie(k, v)
     end
 
     def upgrade(protocol, custom_headers = nil, &block)

data/lib/syntropy/request/session.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require 'base64'
+require 'json'
+require 'securerandom'
+
+module Syntropy
+  class Session
+    def initialize(request)
+      @request = request
+      @data = nil
+    end
+
+    def [](key)
+      @data ||= load
+      @data[key]
+    end
+
+    def []=(key, value)
+      @data ||= load
+      @data[key] = value
+      save(@data)
+    end
+
+    def delete(key)
+      @data ||= load
+      @data.delete(key)
+      save(@data.empty? ? nil : @data)
+    end
+
+    def discard
+      save(nil)
+    end
+
+    def flash
+      @data ||= load
+      @flash ||= Flash.new(self)
+    end
+
+    private
+
+    class NowFlash
+      def initialize
+        @data = {}
+      end
+
+      def [](key)
+        @data[key.to_s]
+      end
+
+      def []=(key, value)
+        @data[key.to_s] = value
+      end
+
+      def each(&block)
+        @data.each { |k, v| block.(k.to_sym, v) }
+      end
+    end
+
+    class Flash
+      def initialize(session)
+        @session = session
+        @current_flash_data = @session['_flash']
+        @session.delete('_flash') if @current_flash_data
+        @current_flash_data ||= {}
+        @future_flash_data = {}
+        @now_flash_data = NowFlash.new
+      end
+
+      def [](key)
+        key = key.to_s
+        @now_flash_data[key] || @current_flash_data[key]
+      end
+
+      def []=(key, value)
+        key = key.to_s
+        @future_flash_data[key] = value
+        @session['_flash'] = @future_flash_data
+      end
+
+      def each(&block)
+        @now_flash_data.each { |k, v| block.(k.to_sym, v) }
+        @current_flash_data.each_pair { |k, v| block.(k.to_sym, v) }
+      end
+
+      def keep
+        @future_flash_data = @current_flash_data.merge!(@future_flash_data)
+        @session['_flash'] = @future_flash_data
+      end
+
+      def now
+        @now_flash_data
+      end
+    end
+
+    # Loads session data from
+    def load
+      data = @request.cookies['__syntropy_session__']
+      return {} if !data
+
+      JSON.parse(Base64.decode64(data))
+    rescue JSON::ParserError
+      {}
+    ensure
+      @loaded = true
+    end
+
+    def save(data)
+      cookie = data ? "#{Base64.strict_encode64(JSON.dump(data))}; Path=/; HttpOnly" : nil
+      @request.set_cookie('__syntropy_session__', cookie)
+    end
+  end
+end

data/lib/syntropy/request/validation.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'uri'
-require 'escape_utils'
 
 module Syntropy
   module RequestValidationMethods
@@ -40,7 +39,7 @@ module Syntropy
     # @clauses [Array] one or more validation clauses
     # @return [any] validated parameter value
     def validate_param(name, *clauses)
-      validate(query[name], *clauses)
+      validate(query[name.to_s], *clauses)
     end
 
     # Validates and optionally converts a value against the given clauses. If no

data/lib/syntropy/request.rb

@@ -3,6 +3,7 @@
 require_relative './request/request_info'
 require_relative './request/validation'
 require_relative './request/response'
+require_relative './request/session'
 require_relative './http/status'
 
 module Syntropy
@@ -95,5 +96,13 @@ module Syntropy
     def total_transfer
       (headers[':rx'] || 0) + (headers[':tx'] || 0)
     end
+
+    def session
+      @session ||= Session.new(self)
+    end
+
+    def flash
+      session.flash
+    end
   end
 end