edgeway 0.1.0 → 0.2.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/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,18 @@ 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
+      prefix = name == Model::PRIMARY ? "" : "database=#{name} "
+      Edgeway.logger.info(prefix + stats.log_text)
     end
   end
 end

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

@@ -7,18 +7,29 @@ require_relative "../../db/adapter"
 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
@@ -29,6 +40,7 @@ module Edgeway
 
         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);
 
@@ -58,12 +70,17 @@ module Edgeway
           return take_result(js_d1_execute(binding, sql, binds));
         }
 
+        const char *d1_exec(const char *binding, const char *sql) {
+          return take_result(js_d1_exec(binding, sql));
+        }
+
         const char *d1_batch(const char *binding, const char *statements) {
           return take_result(js_d1_batch(binding, statements));
         }
       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 +91,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/test.rb

@@ -28,19 +28,40 @@ module Edgeway
   # What a model test needs: a fresh in-memory SQLite database per test
   # (SQLiteAdapter), with the app's db/migrations applied in file name order,
   # so a test can check what was stored (Todo.find, db.select_all) and read
-  # db.log for the SQL. Edgeway's own tests use MemoryAdapter instead, which
-  # stores nothing.
+  # db.log for the SQL. A database under databases: in config/database.yml
+  # gets its own, with db/NAME/migrations, read with db(:name). Edgeway's own
+  # tests use MemoryAdapter instead, which stores nothing.
   class UnitTest < SpinelTest::Unit::TestCase
-    attr_reader :db
-
     def setup
-      @db = Edgeway::DB::SQLiteAdapter.new(":memory:")
-      @db.apply_migrations(File.join(Edgeway::TEST_APP_ROOT, "db/migrations"))
-      Edgeway::Model.connection = @db
+      @databases = {}
+      open_database(Edgeway::Model::PRIMARY, "db/migrations")
+      Edgeway::TEST_DATABASES.each { |name| open_extra_database(name) }
     end
 
     def teardown
-      @db.close
+      @databases.each do |name, database|
+        database.close
+        Edgeway::Model.disconnect(name)
+      end
+    end
+
+    def db(name = Edgeway::Model::PRIMARY) = @databases.fetch(name.to_s)
+
+    private
+
+    def open_extra_database(name)
+      migrations = "db/#{name}/migrations"
+      unless File.directory?(File.join(Edgeway::TEST_APP_ROOT, migrations))
+        raise Edgeway::ConfigurationError, "database #{name} (config/database.yml) has no #{migrations} directory"
+      end
+      open_database(name, migrations)
+    end
+
+    def open_database(name, migrations)
+      database = Edgeway::DB::SQLiteAdapter.new(":memory:")
+      database.apply_migrations(File.join(Edgeway::TEST_APP_ROOT, migrations))
+      Edgeway::Model.connect(name, database)
+      @databases[name] = database
     end
   end
 

data/lib/edgeway/version.rb

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

data/lib/edgeway/view.rb

@@ -0,0 +1,24 @@
+module Edgeway
+  module View
+    ESCAPES = { "&" => "&amp;", "<" => "&lt;", ">" => "&gt;", '"' => "&quot;", "'" => "&#39;" }
+
+    class SafeHTML
+      def initialize(text)
+        @text = text.to_s.dup
+      end
+
+      def to_s = @text
+    end
+
+    def self.escape(obj)
+      return "" if obj.nil?
+      return obj.to_s if obj.is_a?(SafeHTML)
+      s = obj.to_s
+      s.gsub(/[&<>"']/, ESCAPES)
+    end
+  end
+end
+
+class String
+  def html_safe = Edgeway::View::SafeHTML.new(self)
+end

data/lib/edgeway.rb

@@ -1,8 +1,10 @@
 require "json"
 require "time"
+require "uri"
 require_relative "edgeway/version"
 require_relative "edgeway/errors"
 require_relative "edgeway/inflector"
+require_relative "edgeway/view"
 require_relative "edgeway/config"
 require_relative "edgeway/logger"
 require_relative "edgeway/http/response"
@@ -13,6 +15,7 @@ require_relative "edgeway/routing/route"
 require_relative "edgeway/routing/route_set"
 require_relative "edgeway/routing/mapper"
 require_relative "edgeway/db/adapter"
+require_relative "edgeway/model/connection_registry"
 require_relative "edgeway/model/attributes"
 require_relative "edgeway/model/validations"
 require_relative "edgeway/model/macros"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: edgeway
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Yuji Yaginuma
@@ -16,21 +16,26 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - LICENSE.txt
 - README.md
 - exe/edgeway
 - js/cgi.js
+- js/cloudflare-d1-sessions.js
 - js/cloudflare.js
 - js/cors.js
+- js/headers.js
 - js/jwt.js
 - js/runtime.js
 - js/wasi-shim.js
 - lib/edgeway.rb
 - lib/edgeway/application.rb
 - lib/edgeway/cli.rb
-- lib/edgeway/cli/app_config.rb
-- lib/edgeway/cli/app_files.rb
 - lib/edgeway/cli/build.rb
+- lib/edgeway/cli/build/app_config.rb
+- lib/edgeway/cli/build/app_files.rb
+- lib/edgeway/cli/build/database_config.rb
+- lib/edgeway/cli/build/view_compiler.rb
 - lib/edgeway/cli/generate.rb
 - lib/edgeway/cli/new.rb
 - lib/edgeway/cli/package_manager.rb
@@ -47,17 +52,22 @@ files:
 - lib/edgeway/controller/rescuable.rb
 - lib/edgeway/db/adapter.rb
 - lib/edgeway/db/memory.rb
+- lib/edgeway/db/query_stats.rb
 - lib/edgeway/db/sqlite.rb
 - lib/edgeway/errors.rb
+- lib/edgeway/generators/app/templates/.github/workflows/ci.yml.tt
 - lib/edgeway/generators/app/templates/.gitignore
+- lib/edgeway/generators/app/templates/.ruby-version.tt
 - lib/edgeway/generators/app/templates/Gemfile.tt
 - lib/edgeway/generators/app/templates/README.md.tt
 - lib/edgeway/generators/app/templates/app/controllers/application_controller.rb
 - lib/edgeway/generators/app/templates/app/controllers/health_controller.rb
 - lib/edgeway/generators/app/templates/app/models/application_model.rb
+- lib/edgeway/generators/app/templates/app/views/layouts/application.html.erb
 - lib/edgeway/generators/app/templates/bin/build.tt
 - lib/edgeway/generators/app/templates/bin/deploy.tt
 - lib/edgeway/generators/app/templates/bin/setup.tt
+- lib/edgeway/generators/app/templates/bin/test.tt
 - lib/edgeway/generators/app/templates/config/database.yml
 - lib/edgeway/generators/app/templates/config/routes.rb
 - lib/edgeway/generators/app/templates/db/migrations/.keep
@@ -77,6 +87,7 @@ files:
 - lib/edgeway/logger.rb
 - lib/edgeway/model/attributes.rb
 - lib/edgeway/model/base.rb
+- lib/edgeway/model/connection_registry.rb
 - lib/edgeway/model/macros.rb
 - lib/edgeway/model/persistence.rb
 - lib/edgeway/model/relation.rb
@@ -89,11 +100,13 @@ files:
 - lib/edgeway/service/cloudflare/jwt.rb
 - lib/edgeway/test.rb
 - lib/edgeway/version.rb
+- lib/edgeway/view.rb
 homepage: https://github.com/y-yagi/edgeway
 licenses:
 - MIT
 metadata:
   source_code_uri: https://github.com/y-yagi/edgeway
+  changelog_uri: https://github.com/y-yagi/edgeway/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
@@ -109,7 +122,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.17
+rubygems_version: 4.0.16
 specification_version: 4
 summary: A library for Ruby compiled by Spinel to wasm on edge workers.
 test_files: []

data/lib/edgeway/cli/app_config.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Edgeway
-  module CLI
-    class AppConfig
-      # adapter: => the file build/main.rb requires for it.
-      ADAPTERS = {
-        "d1" => "edgeway/service/cloudflare/d1",
-        "memory" => "edgeway/db/memory"
-      }.freeze
-
-      attr_reader :env, :adapter, :binding_name
-
-      def self.load(root, env)
-        path = File.join(root, "config", "database.yml")
-        raise Error, "no config/database.yml in #{root} (is this an Edgeway app?)" unless File.exist?(path)
-
-        section = (YAML.safe_load_file(path) || {})[env]
-        raise Error, "config/database.yml has no #{env} section" unless section.is_a?(Hash)
-
-        new(env, section["adapter"].to_s, (section["binding"] || "DB").to_s)
-      end
-
-      def initialize(env, adapter, binding_name)
-        raise Error, "unknown database adapter #{adapter.inspect} (one of #{ADAPTERS.keys.join(", ")})" unless ADAPTERS.key?(adapter)
-
-        @env = env
-        @adapter = adapter
-        @binding_name = binding_name
-      end
-
-      def adapter_file = ADAPTERS.fetch(@adapter)
-    end
-  end
-end

data/lib/edgeway/cli/app_files.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module Edgeway
-  module CLI
-    class AppFiles
-      def initialize(root)
-        @root = root
-      end
-
-      def require_lines
-        lines = []
-        app = File.join(@root, "app")
-        dirs = Dir.exist?(app) ? Dir.children(app).sort.select { |d| File.directory?(File.join(app, d)) } : []
-        dirs.each do |d|
-          next if %w[models controllers].include?(d)
-
-          lines.concat(requires("app/#{d}"))
-        end
-        lines.concat(requires("app/models"))
-        lines.concat(requires("app/controllers"))
-        lines << 'require_relative "../config/routes"'
-        lines
-      end
-
-      # require_relative lines for the .rb files under dir, application_*.rb first.
-      def requires(dir)
-        full = File.join(@root, dir)
-        return [] unless Dir.exist?(full)
-
-        files = Dir.glob("**/*.rb", base: full).map { |f| File.join(dir, f) }
-        first, rest = files.partition { |f| File.basename(f).start_with?("application_") }
-        # String#dump quotes a path with spaces, quotes or "#{" safely.
-        (first.sort + rest.sort).map { |f| "require_relative #{"../#{f.delete_suffix(".rb")}".dump}" }
-      end
-    end
-  end
-end