edgeway 0.1.0 → 0.3.0

data/lib/edgeway/model/validations.rb

@@ -6,13 +6,13 @@ module Edgeway
       def valid?
         @errors = []
         @raw.each do |col, raw|
-          @errors << "#{col} is out of range" if !raw.nil? && @attributes[col].nil?
+          @errors << "#{col} #{bad_value_text(col)}" if !raw.nil? && @attributes[col].nil?
         end
 
         self.class.rules.each do |rule|
-          col = rule.column
+          col = rule.attribute
           value = rule.kind == "numericality" && @raw.key?(col) ? @raw[col] : @attributes[col]
-          msg = rule.message(value)
+          msg = rule.message(value, self.class.type_of(col))
           @errors << msg unless msg.nil?
         end
 
@@ -26,7 +26,7 @@ module Edgeway
         if @errors.empty?
           self.class.rules.each do |rule|
             next unless rule.kind == "uniqueness"
-            @errors << "#{rule.column} has already been taken" if taken?(rule)
+            @errors << "#{rule.attribute} has already been taken" if taken?(rule)
           end
         end
         @errors.empty?
@@ -34,10 +34,14 @@ module Edgeway
 
       private
 
+      def bad_value_text(column)
+        self.class.type_of(column) == :integer ? "is out of range" : "is invalid"
+      end
+
       def taken?(rule)
-        value = @attributes[rule.column]
+        value = @attributes[rule.attribute]
         return false if value.nil?
-        found = self.class.where(rule.column => value)
+        found = self.class.where(rule.attribute => value)
         rule.scope.each { |c| found = found.where(c => @attributes[self.class.column(c)]) }
         other = found.limit(1).to_a.first
         !other.nil? && (new_record? || other.id != id)
@@ -45,7 +49,7 @@ module Edgeway
     end
 
     class Rule
-      attr_reader :column, :kind
+      attr_reader :attribute, :kind
 
       def self.scope_columns(options)
         return [] if options == true
@@ -70,25 +74,25 @@ module Edgeway
       end
 
       def initialize(attribute, kind, bounds, list, pattern)
-        @column = attribute
+        @attribute = attribute
         @kind = kind
         @bounds = bounds
         @list = list
         @pattern = pattern
       end
 
-      def message(v)
+      def message(v, type = nil)
         # Uniqueness needs a query: Validations#taken? does it.
         return nil if @kind == "uniqueness"
         if @kind == "presence"
-          return "#{@column} can't be blank" if v.nil? || v.to_s.strip.empty?
+          return "#{@attribute} can't be blank" if v.nil? || blank_text?(v.to_s, type)
           return nil
         end
         return nil if v.nil?
         case @kind
-        when "length" then length_message(v.to_s.length)
-        when "inclusion" then @list.include?(v.to_s) ? nil : "#{@column} is not included in the list"
-        when "format" then @pattern.match?(v.to_s) ? nil : "#{@column} is invalid"
+        when "length" then type == :binary ? length_message(v.to_s.bytesize, "bytes") : length_message(v.to_s.length, "characters")
+        when "inclusion" then @list.include?(v.to_s) ? nil : "#{@attribute} is not included in the list"
+        when "format" then @pattern.match?(v.to_s) ? nil : "#{@attribute} is invalid"
         when "numericality" then numericality_message(v)
         end
       end
@@ -97,15 +101,17 @@ module Edgeway
 
       private
 
-      def length_message(n)
+      def blank_text?(text, type) = type == :binary ? text.empty? : text.strip.empty?
+
+      def length_message(n, unit)
         if @bounds.key?("minimum") && n < @bounds["minimum"]
-          return "#{@column} is too short (minimum is #{@bounds["minimum"]} characters)"
+          return "#{@attribute} is too short (minimum is #{@bounds["minimum"]} #{unit})"
         end
         if @bounds.key?("maximum") && n > @bounds["maximum"]
-          return "#{@column} is too long (maximum is #{@bounds["maximum"]} characters)"
+          return "#{@attribute} is too long (maximum is #{@bounds["maximum"]} #{unit})"
         end
         if @bounds.key?("is") && n != @bounds["is"]
-          return "#{@column} is the wrong length (should be #{@bounds["is"]} characters)"
+          return "#{@attribute} is the wrong length (should be #{@bounds["is"]} #{unit})"
         end
         nil
       end
@@ -114,20 +120,20 @@ module Edgeway
         text = v.to_s
         integer = text.match?(/\A[+-]?\d+\z/)
         # Decimals and exponents too: Float#to_s writes 1.0e+20 and 1.0e-05.
-        return "#{@column} is not a number" unless integer || text.match?(/\A[+-]?\d+(\.\d+)?([eE][+-]?\d+)?\z/)
-        return "#{@column} must be an integer" if @bounds.key?("only_integer") && !integer
+        return "#{@attribute} is not a number" unless integer || text.match?(/\A[+-]?\d+(\.\d+)?([eE][+-]?\d+)?\z/)
+        return "#{@attribute} must be an integer" if @bounds.key?("only_integer") && !integer
         n = text.to_f
         if @bounds.key?("greater_than") && !(n > @bounds["greater_than"])
-          return "#{@column} must be greater than #{@bounds["greater_than"]}"
+          return "#{@attribute} must be greater than #{@bounds["greater_than"]}"
         end
         if @bounds.key?("greater_than_or_equal_to") && !(n >= @bounds["greater_than_or_equal_to"])
-          return "#{@column} must be greater than or equal to #{@bounds["greater_than_or_equal_to"]}"
+          return "#{@attribute} must be greater than or equal to #{@bounds["greater_than_or_equal_to"]}"
         end
         if @bounds.key?("less_than") && !(n < @bounds["less_than"])
-          return "#{@column} must be less than #{@bounds["less_than"]}"
+          return "#{@attribute} must be less than #{@bounds["less_than"]}"
         end
         if @bounds.key?("less_than_or_equal_to") && !(n <= @bounds["less_than_or_equal_to"])
-          return "#{@column} must be less than or equal to #{@bounds["less_than_or_equal_to"]}"
+          return "#{@attribute} must be less than or equal to #{@bounds["less_than_or_equal_to"]}"
         end
         nil
       end

data/lib/edgeway/rate_limit/limiter.rb

@@ -0,0 +1,9 @@
+module Edgeway
+  module RateLimit
+    class Limiter
+      def exceeded?(binding_name, key)
+        raise Edgeway::Error, "#{self.class.name} does not check limits"
+      end
+    end
+  end
+end

data/lib/edgeway/rate_limit/null_limiter.rb

@@ -0,0 +1,9 @@
+require_relative "limiter"
+
+module Edgeway
+  module RateLimit
+    class NullLimiter < Limiter
+      def exceeded?(binding_name, key) = false
+    end
+  end
+end

data/lib/edgeway/rate_limit/stub_limiter.rb

@@ -0,0 +1,24 @@
+require_relative "limiter"
+
+module Edgeway
+  module RateLimit
+    class StubLimiter < Limiter
+      attr_reader :checks
+
+      def initialize
+        @exceeded_bindings = []
+        @checks = []
+      end
+
+      def stub(binding_name, exceeded)
+        @exceeded_bindings.delete(binding_name)
+        @exceeded_bindings << binding_name if exceeded
+      end
+
+      def exceeded?(binding_name, key)
+        @checks << [binding_name, key]
+        @exceeded_bindings.include?(binding_name)
+      end
+    end
+  end
+end

data/lib/edgeway/rate_limit.rb

@@ -0,0 +1,2 @@
+require_relative "rate_limit/limiter"
+require_relative "rate_limit/null_limiter"

data/lib/edgeway/routing/route.rb

@@ -13,12 +13,7 @@ module Edgeway
 
       def self.split(path) = path.split("/").reject(&:empty?)
 
-      def controller_class_name
-        parts = @controller_path.split("/").map do |part|
-          part.split("_").map(&:capitalize).join
-        end
-        parts.join("::") + "Controller"
-      end
+      def controller_class_name = Inflector.controller_class_name(@controller_path)
 
       def match(verb, path)
         return nil unless verb == @verb || (verb == "HEAD" && @verb == "GET")

data/lib/edgeway/server.rb

@@ -7,6 +7,19 @@ module Edgeway
     def self.run
       response = Edgeway.application.call(HTTP::Request.from_env)
       print response.to_cgi
+      log_query_stats
+    end
+
+    def self.log_query_stats
+      Model.database_names.each { |name| log_database_stats(name) }
+    end
+
+    def self.log_database_stats(name)
+      stats = Model.query_stats(name)
+      return unless stats.queries > 0
+      fields = stats.log_fields
+      fields["database"] = name.to_s unless name == Model::PRIMARY
+      Edgeway.logger.info("query stats", fields)
     end
   end
 end

data/lib/edgeway/service/cloudflare/d1.rb

@@ -3,67 +3,69 @@
 # Spinel's, so CRuby can't read it (tests use edgeway/db/memory).
 require "json"
 require_relative "../../db/adapter"
+require_relative "../import_result"
 
 module Edgeway
   module Cloudflare
     # The imports as Ruby methods: d1_query and d1_execute take the binding
-    # name, the SQL and the binds (JSON text); d1_batch takes the binding name
+    # name, the SQL and the binds (JSON text); d1_exec takes the binding name
+    # and SQL text of one or more statements; d1_batch takes the binding name
     # and the statements ([[sql, binds], ...], JSON text), and answer the result as JSON
     # text:
     #
-    #   d1_query    {"rows": [...]}
-    #   d1_execute  {"changes": n, "last_insert_id": id}
-    #   d1_batch    {"results": [{"changes": n, "last_insert_id": id}, ...]}
+    #   d1_query    {"rows": [...], "meta": META}
+    #   d1_execute  {"changes": n, "last_insert_id": id, "meta": META}
+    #   d1_exec     {"count": n, "meta": META}
+    #   d1_batch    {"results": [{"changes": n, "last_insert_id": id}, ...], "meta": META}
+    #   META        {"rows_read": n, "rows_written": n, "duration": ms,
+    #                "served_by_region": "...", "served_by_primary": bool}
+    #               (a batch's is the sum over its statements)
+    #   BLOB        a bind or a column value that is a BLOB is {"$blob": "<base64>"}
+    #               (raw bytes can't cross: JSON text holds no arbitrary bytes)
+    #   last_insert_id  is a number; a rowid beyond 32 bits is a Bignum here,
+    #               which last_insert_id_of turns into its decimal String
     #   any         {"error": "message"} when D1 failed
+    #   any         {"error": "message", "unavailable": true} when it failed
+    #               in a transient way (DatabaseUnavailable)
     #
-    # An import can't hand a string to wasm, so a call is two: query/execute
-    # runs the statement and answers the byte length of its result, and
-    # take(buf) copies the result into buf. JS wraps query and execute in
+    # An import can't hand a string to wasm, so a call is two: each import
+    # runs the statement(s) and answers the byte length of its result, and
+    # take(buf) copies the result into buf. JS wraps each import in
     # WebAssembly.Suspending: the D1 Promise is awaited with the wasm stack
     # suspended (JSPI), so they read like blocking calls here.
     module D1Imports
       ffi_source <<~C
-        #include <stdlib.h>
-
         #define D1_IMPORT(name) __attribute__((import_module("edgeway_d1"), import_name(name)))
 
         D1_IMPORT("query")   int  js_d1_query(const char *binding, const char *sql, const char *binds);
         D1_IMPORT("execute") int  js_d1_execute(const char *binding, const char *sql, const char *binds);
+        D1_IMPORT("exec")    int  js_d1_exec(const char *binding, const char *sql);
         D1_IMPORT("batch")   int  js_d1_batch(const char *binding, const char *statements);
         D1_IMPORT("take")    void js_d1_take(char *buf);
 
-        /* The last result, NUL-terminated; grown as needed and reused. */
-        static char *result;
-        static int result_cap;
-
-        static const char *take_result(int length) {
-          if (length + 1 > result_cap) {
-            char *grown = realloc(result, length + 1);
-            if (!grown) abort();
-            result = grown;
-            result_cap = length + 1;
-          }
-          js_d1_take(result);
-          result[length] = 0;
-          return result;
-        }
+        static ImportResultBuffer d1_result;
 
         /* What ffi_func binds. Its own extern declaration would lose the
            import attributes, so the imports are wrapped. */
         const char *d1_query(const char *binding, const char *sql, const char *binds) {
-          return take_result(js_d1_query(binding, sql, binds));
+          return take_import_result(&d1_result, js_d1_query(binding, sql, binds), js_d1_take);
         }
 
         const char *d1_execute(const char *binding, const char *sql, const char *binds) {
-          return take_result(js_d1_execute(binding, sql, binds));
+          return take_import_result(&d1_result, js_d1_execute(binding, sql, binds), js_d1_take);
+        }
+
+        const char *d1_exec(const char *binding, const char *sql) {
+          return take_import_result(&d1_result, js_d1_exec(binding, sql), js_d1_take);
         }
 
         const char *d1_batch(const char *binding, const char *statements) {
-          return take_result(js_d1_batch(binding, statements));
+          return take_import_result(&d1_result, js_d1_batch(binding, statements), js_d1_take);
         }
       C
       ffi_func :d1_query, [:str, :str, :str], :str
       ffi_func :d1_execute, [:str, :str, :str], :str
+      ffi_func :d1_exec, [:str, :str], :str
       ffi_func :d1_batch, [:str, :str], :str
     end
 
@@ -74,26 +76,38 @@ module Edgeway
       end
 
       def select_all(sql, binds)
+        check_binds(binds)
         result(D1Imports.d1_query(@binding_name, sql, JSON.generate(binds)))["rows"]
       end
 
       def execute(sql, binds)
+        check_binds(binds)
         res = result(D1Imports.d1_execute(@binding_name, sql, JSON.generate(binds)))
-        { "changes" => res["changes"].to_i, "last_insert_id" => res["last_insert_id"].to_i }
+        write_result(res)
+      end
+
+      def exec(sql)
+        result(D1Imports.d1_exec(@binding_name, sql))
       end
 
       # One D1 batch(): the statements run as a single transaction, so any
       # failure rolls all of them back.
       def batch(statements)
+        statements.each { |s| check_binds(s[1]) }
         res = result(D1Imports.d1_batch(@binding_name, JSON.generate(statements)))
-        res["results"].map { |r| { "changes" => r["changes"].to_i, "last_insert_id" => r["last_insert_id"].to_i } }
+        res["results"].map { |entry| write_result(entry) }
       end
 
       private
 
+      def write_result(entry)
+        { "changes" => entry["changes"].to_i, "last_insert_id" => last_insert_id_of(entry["last_insert_id"]) }
+      end
+
       def result(json)
         res = JSON.parse(json)
-        fail_with("d1: #{res["error"]}") if res.key?("error")
+        raise_error_result(res, "d1: ") if res.key?("error")
+        record_meta(res["meta"]) if res.key?("meta")
         res
       end
     end

data/lib/edgeway/service/cloudflare/jwt.rb

@@ -3,33 +3,21 @@
 # (ffi_source is Spinel's; tests use edgeway/http/auth/stub).
 require "json"
 require_relative "../../http/auth/jwt"
+require_relative "../import_result"
 
 module Edgeway
   module Cloudflare
     module JWTImports
       ffi_source <<~C
-        #include <stdlib.h>
-
         #define JWT_IMPORT(name) __attribute__((import_module("edgeway_jwt"), import_name(name)))
 
         JWT_IMPORT("verify") int  js_jwt_verify(const char *token);
         JWT_IMPORT("take")   void js_jwt_take(char *buf);
 
-        /* The last result, NUL-terminated; grown as needed and reused. */
-        static char *jwt_result;
-        static int jwt_result_cap;
+        static ImportResultBuffer jwt_result;
 
         const char *jwt_verify(const char *token) {
-          int length = js_jwt_verify(token);
-          if (length + 1 > jwt_result_cap) {
-            char *grown = realloc(jwt_result, length + 1);
-            if (!grown) abort();
-            jwt_result = grown;
-            jwt_result_cap = length + 1;
-          }
-          js_jwt_take(jwt_result);
-          jwt_result[length] = 0;
-          return jwt_result;
+          return take_import_result(&jwt_result, js_jwt_verify(token), js_jwt_take);
         }
       C
       ffi_func :jwt_verify, [:str], :str

data/lib/edgeway/service/cloudflare/kv.rb

@@ -0,0 +1,45 @@
+require "json"
+require_relative "../import_result"
+require_relative "kv_store"
+
+module Edgeway
+  module Cloudflare
+    module KVImports
+      ffi_source <<~C
+        #define KV_IMPORT(name) __attribute__((import_module("edgeway_kv"), import_name(name)))
+
+        KV_IMPORT("get")    int  js_kv_get(const char *binding, const char *key);
+        KV_IMPORT("put")    int  js_kv_put(const char *binding, const char *key, const char *text, int expires_in);
+        KV_IMPORT("delete") int  js_kv_delete(const char *binding, const char *key);
+        KV_IMPORT("take")   void js_kv_take(char *buffer);
+
+        static ImportResultBuffer kv_result;
+
+        const char *kv_get(const char *binding, const char *key) {
+          return take_import_result(&kv_result, js_kv_get(binding, key), js_kv_take);
+        }
+
+        const char *kv_put(const char *binding, const char *key, const char *text, int expires_in) {
+          return take_import_result(&kv_result, js_kv_put(binding, key, text, expires_in), js_kv_take);
+        }
+
+        const char *kv_delete(const char *binding, const char *key) {
+          return take_import_result(&kv_result, js_kv_delete(binding, key), js_kv_take);
+        }
+      C
+      ffi_func :kv_get, [:str, :str], :str
+      ffi_func :kv_put, [:str, :str, :str, :int], :str
+      ffi_func :kv_delete, [:str, :str], :str
+    end
+
+    class KVImportTransport < KVTransport
+      def get(binding_name, key) = KVImports.kv_get(binding_name, key)
+
+      def put(binding_name, key, text, expires_in_seconds)
+        KVImports.kv_put(binding_name, key, text, expires_in_seconds)
+      end
+
+      def delete(binding_name, key) = KVImports.kv_delete(binding_name, key)
+    end
+  end
+end

data/lib/edgeway/service/cloudflare/kv_store.rb

@@ -0,0 +1,58 @@
+require "json"
+require_relative "../../cache/store"
+
+module Edgeway
+  module Cloudflare
+    class KVTransport
+      def get(binding_name, key)
+        raise Edgeway::Error, "#{self.class.name} does not get"
+      end
+
+      def put(binding_name, key, text, expires_in_seconds)
+        raise Edgeway::Error, "#{self.class.name} does not put"
+      end
+
+      def delete(binding_name, key)
+        raise Edgeway::Error, "#{self.class.name} does not delete"
+      end
+    end
+
+    class KVStore < Cache::Store
+      def initialize(binding:, namespace: nil, expires_in: nil, transport:)
+        super(namespace: namespace, expires_in: expires_in)
+        @binding_name = binding
+        @transport = transport
+      end
+
+      def read_text(key)
+        check_key(key)
+        answer = parse_answer("get", @transport.get(@binding_name, key))
+        answer.nil? ? nil : answer["value"]
+      end
+
+      def write_text(key, text, expires_in_seconds)
+        check_key(key)
+        !parse_answer("put", @transport.put(@binding_name, key, text, expires_in_seconds)).nil?
+      end
+
+      def delete_text(key)
+        check_key(key)
+        !parse_answer("delete", @transport.delete(@binding_name, key)).nil?
+      end
+
+      private
+
+      def check_key(key)
+        raise ArgumentError, "cache key can't be . or .." if key == "." || key == ".."
+      end
+
+      def parse_answer(operation, json)
+        answer = JSON.parse(json)
+        return answer unless answer.key?("error")
+
+        Edgeway.logger.warn("cache operation failed", { "operation" => operation, "binding" => @binding_name, "error" => answer["error"] })
+        nil
+      end
+    end
+  end
+end

data/lib/edgeway/service/cloudflare/rate_limit.rb

@@ -0,0 +1,27 @@
+require "json"
+require_relative "../import_result"
+require_relative "rate_limiter"
+
+module Edgeway
+  module Cloudflare
+    module RateLimitImports
+      ffi_source <<~C
+        #define RATE_LIMIT_IMPORT(name) __attribute__((import_module("edgeway_ratelimit"), import_name(name)))
+
+        RATE_LIMIT_IMPORT("check") int  js_rate_limit_check(const char *binding, const char *key);
+        RATE_LIMIT_IMPORT("take")  void js_rate_limit_take(char *buffer);
+
+        static ImportResultBuffer rate_limit_result;
+
+        const char *rate_limit_check(const char *binding, const char *key) {
+          return take_import_result(&rate_limit_result, js_rate_limit_check(binding, key), js_rate_limit_take);
+        }
+      C
+      ffi_func :rate_limit_check, [:str, :str], :str
+    end
+
+    class RateLimitImportTransport < RateLimitTransport
+      def check(binding_name, key) = RateLimitImports.rate_limit_check(binding_name, key)
+    end
+  end
+end

data/lib/edgeway/service/cloudflare/rate_limiter.rb

@@ -0,0 +1,33 @@
+require "json"
+require_relative "../../rate_limit"
+
+module Edgeway
+  module Cloudflare
+    class RateLimitTransport
+      def check(binding_name, key)
+        raise Edgeway::Error, "#{self.class.name} does not check"
+      end
+    end
+
+    class RateLimiter < RateLimit::Limiter
+      def initialize(transport:)
+        @transport = transport
+      end
+
+      def exceeded?(binding_name, key)
+        answer = JSON.parse(@transport.check(binding_name, Digest::SHA256.hexdigest(key)))
+        raise ConfigurationError, "rate limit: #{answer["misconfigured"]}" if answer.key?("misconfigured")
+        return failed_open(binding_name, answer["error"]) if answer.key?("error")
+
+        answer["success"] == false
+      end
+
+      private
+
+      def failed_open(binding_name, message)
+        Edgeway.logger.warn("rate limit check failed", { "binding" => binding_name, "error" => message })
+        false
+      end
+    end
+  end
+end

data/lib/edgeway/service/cloudflare/test_databases.rb

@@ -0,0 +1,65 @@
+require_relative "d1"
+
+module Edgeway
+  module Cloudflare
+    module TestImports
+      ffi_source <<~C
+        __attribute__((import_module("edgeway_test"), import_name("reset"))) void js_test_reset(void);
+
+        int test_reset(void) {
+          js_test_reset();
+          return 0;
+        }
+      C
+      ffi_func :test_reset, [], :int
+    end
+
+    class TestD1Adapter < D1Adapter
+      attr_reader :log
+
+      def initialize(binding: "DB")
+        super(binding: binding)
+        @log = []
+      end
+
+      def select_all(sql, binds)
+        log_statement(sql, binds)
+        super(sql, binds)
+      end
+
+      def execute(sql, binds)
+        log_statement(sql, binds)
+        super(sql, binds)
+      end
+
+      def exec(sql)
+        log_statement(sql, [])
+        super(sql)
+      end
+
+      def batch(statements)
+        @log << "BATCH #{statements.size}"
+        super(statements)
+      end
+
+      def close
+      end
+
+      private
+
+      def log_statement(sql, binds)
+        @log << "#{sql} | #{JSON.generate(binds)}"
+      end
+    end
+  end
+
+  module TestDatabases
+    def self.reset
+      Cloudflare::TestImports.test_reset
+    end
+
+    def self.open(name)
+      Cloudflare::TestD1Adapter.new(binding: Edgeway::TEST_BINDINGS.fetch(name))
+    end
+  end
+end

data/lib/edgeway/service/fetch.rb

@@ -0,0 +1,26 @@
+require_relative "../http/client"
+require_relative "import_result"
+
+module Edgeway
+  module FetchImports
+    ffi_source <<~C
+      #define FETCH_IMPORT(name) __attribute__((import_module("edgeway_fetch"), import_name(name)))
+
+      FETCH_IMPORT("request") int  js_fetch_request(const char *payload);
+      FETCH_IMPORT("take")    void js_fetch_take(char *buffer);
+
+      static ImportResultBuffer fetch_result;
+
+      const char *fetch_request(const char *payload) {
+        return take_import_result(&fetch_result, js_fetch_request(payload), js_fetch_take);
+      }
+    C
+    ffi_func :fetch_request, [:str], :str
+  end
+
+  class FetchTransport < HTTP::Transport
+    def request(payload)
+      FetchImports.fetch_request(payload)
+    end
+  end
+end