edgeway 0.1.0 → 0.3.0

data/lib/edgeway/cli/cloudflare_test.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "shellwords"
+require "open3"
+
+module Edgeway
+  module CLI
+    class CloudflareTest < Test
+      RUNTIME_DIR = "tmp/edgeway"
+      RUNNER = "cloudflare-test-runner.js"
+      MIN_NODE_MAJOR = 24
+
+      # The apps whose test environment uses the d1 adapter.
+      def self.handles?(database)
+        database.section?("test") && database.section("test")["adapter"] == "d1"
+      end
+
+      def initialize(root)
+        super
+        @config = Build::AppConfig.load(root, "test")
+      end
+
+      def run(args)
+        check_prerequisites
+        write_test_app
+        write_runtime
+        require_spinel_test_unit
+        argv = ["-I", @root, "-I", CLI.gem_dir + "/lib", *args]
+        exit WasmTestCLI.new(argv, root: @root, launcher: launcher).run
+      end
+
+      private
+
+      def database_lines
+        [
+          'require "edgeway/db/memory"',
+          'require "edgeway/service/cloudflare/test_databases"',
+          'require "edgeway/service/cloudflare/jwt"',
+          'require "edgeway/service/fetch"',
+          "module Edgeway; TEST_DATABASES = #{@config.databases.keys.inspect}; end",
+          "module Edgeway; TEST_BINDINGS = #{bindings.inspect}; end"
+        ]
+      end
+
+      def bindings
+        { "primary" => @config.binding_name }.merge(@config.databases)
+      end
+
+      def migration_directories
+        { "primary" => "db/migrations" }.merge(@config.databases.to_h { |name, _binding| [name, "db/#{name}/migrations"] })
+      end
+
+      def write_runtime
+        databases = bindings.map do |name, binding_name|
+          { "binding" => binding_name, "migrations" => File.join(@root, migration_directories.fetch(name)) }
+        end
+        values = {
+          "env" => "test", "d1Binding" => @config.binding_name, "sessions" => @config.sessions,
+          "appRoot" => @root, "databases" => databases
+        }
+        directory = File.join(@root, RUNTIME_DIR)
+        Build::JsFiles.copy(directory, Build::JsFiles.config_js(values, "test"), tests: true)
+        File.write(File.join(directory, "package.json"), %({"type": "module"}\n))
+      end
+
+      def launcher
+        ["node", *node_flags, File.join(@root, RUNTIME_DIR, RUNNER)]
+      end
+
+      def node_flags
+        has_jspi = system("node", "-e", "process.exit(typeof WebAssembly.Suspending === 'function' ? 0 : 1)")
+        has_jspi ? [] : ["--experimental-wasm-jspi", "--experimental-wasm-exnref"]
+      end
+
+      def require_spinel_test_unit
+        require "spinel_test/unit/cli"
+        require_relative "cloudflare_test/wasm_test_cli"
+      rescue LoadError
+        raise Error, 'spinel_test-unit is not installed (add gem "spinel_test-unit", "~> 0.1", group: :test to the Gemfile and run bundle install)'
+      end
+
+      def check_prerequisites
+        check_node
+        raise Error, "no wrangler.toml in #{@root} (the tests run on the local D1 it describes)" unless File.exist?(File.join(@root, "wrangler.toml"))
+
+        check_wrangler
+        raise Error, "no WASI SDK found (install it with mise, or set WASI_SDK=/path/to/wasi-sdk)" unless Toolchain.wasi_sdk
+        raise Error, "no Spinel compiler found (install it with mise, or set SPINEL=/path/to/spinel)" unless Toolchain.spinel
+
+        check_migration_directories
+      end
+
+      def check_node
+        raise Error, "node is not installed; `edgeway test` runs the tests on the local D1 of wrangler, which needs Node.js #{MIN_NODE_MAJOR} or later" unless Toolchain.find_on_path("node")
+
+        version, = Open3.capture2("node", "-p", "process.versions.node")
+        return if version.to_i >= MIN_NODE_MAJOR
+
+        raise Error, "Node.js #{version.strip} is too old: `edgeway test` needs #{MIN_NODE_MAJOR} or later (WebAssembly JSPI)"
+      end
+
+      def check_wrangler
+        return if File.directory?(File.join(@root, "node_modules/wrangler"))
+
+        raise Error, "wrangler is not installed in #{@root}/node_modules; run #{PackageManager.install} (or bin/setup)"
+      end
+
+      def check_migration_directories
+        @config.databases.each_key do |name|
+          directory = migration_directories.fetch(name)
+          next if File.directory?(File.join(@root, directory))
+
+          raise Error, "database #{name} (config/database.yml) has no #{directory} directory"
+        end
+      end
+    end
+
+    Test::PLATFORMS << CloudflareTest
+  end
+end

data/lib/edgeway/cli/generate.rb

@@ -9,32 +9,37 @@ module Edgeway
       USAGE = <<~TEXT
         Usage: edgeway generate model NAME [field:type ...]
                edgeway generate controller NAME [action ...]
+               edgeway generate scaffold NAME [field:type ...]
 
         Types: #{%w[string text integer float boolean datetime].join(", ")} (default string)
       TEXT
 
-      # field type => [the column's SQL type, its attribute type]
+      # field type => its column's SQL type, its attribute type, and the values
+      # (as Ruby source) the scaffold's test creates and updates with.
       # D1 is SQLite, which has no datetime/boolean type (only NULL, INTEGER,
       # REAL, TEXT and BLOB): a datetime is TEXT (ISO 8601, as Model.now
       # writes it) and a boolean is an INTEGER 0/1. It is SQLite's, not a
       # Cloudflare, limit.
+      Type = Struct.new(:sql, :attr, :created, :updated)
       TYPES = {
-        "string" => ["TEXT", ":string"],
-        "text" => ["TEXT", ":string"],
-        "integer" => ["INTEGER", ":integer"],
-        "float" => ["REAL", ":float"],
-        "boolean" => ["INTEGER NOT NULL DEFAULT 0", ":boolean"],
-        "datetime" => ["TEXT", ":datetime"]
+        "string" => Type.new("TEXT", ":string", '"MyString"', '"Updated"'),
+        "text" => Type.new("TEXT", ":string", '"MyText"', '"Updated"'),
+        "integer" => Type.new("INTEGER", ":integer", "1", "2"),
+        "float" => Type.new("REAL", ":float", "1.5", "2.5"),
+        "boolean" => Type.new("INTEGER NOT NULL DEFAULT 0", ":boolean", "true", "false"),
+        "datetime" => Type.new("TEXT", ":datetime", '"2026-01-01T00:00:00Z"', '"2026-02-01T00:00:00Z"')
       }.freeze
 
+      Field = Struct.new(:name, :sql, :attr, :created, :updated)
+
       RESOURCE_ACTIONS = %w[index show create update destroy].freeze
 
       def self.run(args)
         kind, name, *rest = args
-        raise Error, USAGE unless %w[model controller].include?(kind) && name && !name.start_with?("-")
+        raise Error, USAGE unless %w[model controller scaffold].include?(kind) && name && !name.start_with?("-")
 
         generator = new(Dir.pwd)
-        kind == "model" ? generator.model(name, rest) : generator.controller(name, rest)
+        generator.public_send(kind, name, rest)
       end
 
       def initialize(root)
@@ -46,21 +51,32 @@ module Edgeway
 
       def model(name, fields)
         base = underscore(name)
-        table = Inflector.pluralize(base)
         columns = fields.map { |f| parse_field(f) }
-        write("app/models/#{base}.rb", model_source(camelize(base), columns))
-        write("db/migrations/#{next_migration_number}_create_#{table}.sql", migration_source(table, columns))
-        write("test/models/#{base}_test.rb", model_test_source(camelize(base)))
-        puts "\nApply the migration locally: #{PackageManager.exec} wrangler d1 migrations apply DB_NAME --local"
+        write_all(model_files(base, columns))
+        puts_migration_hint
       end
 
       def controller(name, actions)
         base = underscore(name).delete_suffix("_controller")
         actions.each { |a| raise Error, "invalid action name: #{a}" unless a.match?(/\A[a-z_][a-z0-9_]*\z/) }
-        write("app/controllers/#{base}_controller.rb", controller_source(camelize(base), actions))
-        write("test/controllers/#{base}_test.rb", controller_test_source(camelize(base)))
-        puts "\nAdd to config/routes.rb:"
-        route_hints(base, actions).each { |l| puts "  #{l}" }
+        write_all([
+          ["app/controllers/#{base}_controller.rb", controller_source(camelize(base), actions)],
+          ["test/controllers/#{base}_test.rb", controller_test_source(camelize(base))]
+        ])
+        puts_route_hints(route_hints(base, actions))
+      end
+
+      def scaffold(name, fields)
+        base = underscore(Inflector.singularize(name))
+        plural = Inflector.pluralize(base)
+        columns = fields.map { |f| parse_field(f) }
+        # Every path is checked before the first is written: no half a scaffold.
+        write_all(model_files(base, columns) + [
+          ["app/controllers/#{plural}_controller.rb", scaffold_controller_source(camelize(base), plural, columns)],
+          ["test/controllers/#{plural}_test.rb", scaffold_test_source(camelize(base), plural, columns)]
+        ])
+        add_route(plural)
+        puts_migration_hint
       end
 
       private
@@ -71,21 +87,60 @@ module Edgeway
         name.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
       end
 
-      def camelize(name) = name.split("_").map(&:capitalize).join
+      def camelize(name) = Inflector.camelize(name)
 
-      # "title:string" => ["title", "TEXT", ":string"]
+      # "title:string" => Field.new("title", "TEXT", ":string", '"MyString"', '"Updated"')
       def parse_field(spec)
         name, type = spec.split(":", 2)
         type ||= "string"
         raise Error, "invalid field name: #{spec}" unless name.match?(/\A[a-z_][a-z0-9_]*\z/)
         raise Error, "unknown field type #{type} (#{TYPES.keys.join(", ")})" unless TYPES.key?(type)
 
-        [name, *TYPES[type]]
+        Field.new(name, *TYPES[type].to_a)
+      end
+
+      def model_files(base, columns)
+        table = Inflector.pluralize(base)
+        existing = Dir.glob("db/migrations/*_create_#{table}.sql", base: @root).first
+        raise Error, "#{existing} already exists" if existing
+
+        [
+          ["app/models/#{base}.rb", model_source(camelize(base), columns)],
+          ["db/migrations/#{next_migration_number}_create_#{table}.sql", migration_source(table, columns)],
+          ["test/models/#{base}_test.rb", model_test_source(camelize(base))]
+        ]
+      end
+
+      def puts_migration_hint
+        puts "\nApply the migration locally: #{PackageManager.exec} wrangler d1 migrations apply DB_NAME --local"
+      end
+
+      def add_route(plural)
+        path = File.join(@root, "config/routes.rb")
+        text = File.read(path)
+        match = text.match(/^([ \t]*)[\w.]*routes\.draw[ \t]+do[ \t]*\|[ \t]*(\w+)[ \t]*\|[ \t]*(\r?\n)/)
+        return puts_route_hints(["r.resources :#{plural}"], "no `routes.draw do |r|` block found") unless match
+
+        indent, var, eol = match.captures
+        line = "#{var}.resources :#{plural}"
+        return puts "  identical  #{line}" if text.match?(/^[ \t]*#{Regexp.escape(var)}\.resources[ \t]*\(?[ \t]*:#{plural}(?!\w)/)
+
+        close = text.index(/^#{Regexp.escape(indent)}end\b/, match.end(0))
+        return puts_route_hints([line], "no closing `end` found") unless close
+
+        File.write(path, text[0...close] + "#{indent}  #{line}#{eol}" + text[close..])
+        puts "  route  #{line}"
+      end
+
+      def puts_route_hints(hints, reason = nil)
+        puts "\nconfig/routes.rb not changed: #{reason}" if reason
+        puts "\nAdd to config/routes.rb:"
+        hints.each { |l| puts "  #{l}" }
       end
 
       def model_source(klass, columns)
-        lines = columns.map do |name, _sql, attr|
-          attr == ":boolean" ? "  attribute :#{name}, :boolean, default: false" : "  attribute :#{name}, #{attr}"
+        lines = columns.map do |c|
+          c.attr == ":boolean" ? "  attribute :#{c.name}, :boolean, default: false" : "  attribute :#{c.name}, #{c.attr}"
         end
         lines << "  timestamps"
         "class #{klass} < ApplicationModel\n#{lines.join("\n")}\nend\n"
@@ -93,7 +148,7 @@ module Edgeway
 
       def migration_source(table, columns)
         lines = ["  id INTEGER PRIMARY KEY AUTOINCREMENT"]
-        columns.each { |name, sql, _attr| lines << "  #{name} #{sql}" }
+        columns.each { |c| lines << "  #{c.name} #{c.sql}" }
         lines << "  created_at TEXT" << "  updated_at TEXT"
         "CREATE TABLE #{table} (\n#{lines.join(",\n")}\n);\n"
       end
@@ -130,6 +185,96 @@ module Edgeway
         RUBY
       end
 
+      def scaffold_controller_source(klass, plural, columns)
+        var = underscore(klass)
+        lines = [
+          "class #{camelize(plural)}Controller < ApplicationController",
+          "  def index = render json: #{klass}.order(:id).limit(50)",
+          "",
+          "  def show = render json: #{klass}.find(params[:id])",
+          "",
+          "  def create",
+          "    #{var} = #{columns.empty? ? "#{klass}.create!" : "#{klass}.create!(#{var}_params)"}",
+          "    render json: #{var}, status: :created",
+          "  end",
+          "",
+          "  def update",
+          "    #{var} = #{klass}.find(params[:id])"
+        ]
+        lines << "    #{var}.update!(#{var}_params)" unless columns.empty?
+        lines += [
+          "    render json: #{var}",
+          "  end",
+          "",
+          "  def destroy",
+          "    #{klass}.find(params[:id]).destroy",
+          "    head :no_content",
+          "  end"
+        ]
+        unless columns.empty?
+          permitted = columns.map { |c| ":#{c.name}" }.join(", ")
+          lines += ["", "  private", "", "  def #{var}_params = params.require(:#{var}).permit(#{permitted})"]
+        end
+        lines << "end"
+        lines.join("\n") + "\n"
+      end
+
+      def scaffold_test_source(klass, plural, columns)
+        var = underscore(klass)
+        create_args = columns.empty? ? "" : "(#{columns.map { |c| "#{c.name}: #{c.created}" }.join(", ")})"
+        hash = lambda do |value|
+          columns.empty? ? "{}" : "{ #{columns.map { |c| "\"#{c.name}\" => #{c.public_send(value)}" }.join(", ")} }"
+        end
+        checks = ->(value) { columns.map { |c| "    assert_equal #{c.public_send(value)}, json[\"#{c.name}\"]" }.join("\n") }
+        <<~RUBY
+          require "edgeway/test"
+          require "test_helper"
+
+          class #{camelize(plural)}Test < Edgeway::IntegrationTest
+            def test_index
+              #{var} = #{klass}.create!#{create_args}
+              get "/#{plural}"
+              assert_response 200
+              assert_equal 1, json.size
+              assert_equal #{var}.id, json[0]["id"]
+            end
+
+            def test_show
+              #{var} = #{klass}.create!#{create_args}
+              get "/#{plural}/\#{#{var}.id}"
+              assert_response 200
+              assert_equal #{var}.id, json["id"]
+            end
+
+            def test_show_not_found
+              get "/#{plural}/0"
+              assert_response 404
+            end
+
+            def test_create
+              post "/#{plural}", json: { "#{var}" => #{hash.call(:created)} }
+              assert_response 201
+              assert_equal 1, #{klass}.count
+          #{checks.call(:created)}
+            end
+
+            def test_update
+              #{var} = #{klass}.create!#{create_args}
+              patch "/#{plural}/\#{#{var}.id}", json: { "#{var}" => #{hash.call(:updated)} }
+              assert_response 200
+          #{checks.call(:updated)}
+            end
+
+            def test_destroy
+              #{var} = #{klass}.create!#{create_args}
+              delete "/#{plural}/\#{#{var}.id}"
+              assert_response 204
+              assert_equal 0, #{klass}.count
+            end
+          end
+        RUBY
+      end
+
       def route_hints(base, actions)
         return ["r.resources :#{base}"] if actions.empty?
 
@@ -147,10 +292,13 @@ module Edgeway
         format("%04d", last + 1)
       end
 
+      def write_all(files)
+        files.each { |rel, _text| raise Error, "#{rel} already exists" if File.exist?(File.join(@root, rel)) }
+        files.each { |rel, text| write(rel, text) }
+      end
+
       def write(rel, text)
         dest = File.join(@root, rel)
-        raise Error, "#{rel} already exists" if File.exist?(dest)
-
         FileUtils.mkdir_p(File.dirname(dest))
         File.write(dest, text)
         puts "  create  #{rel}"

data/lib/edgeway/cli/new.rb

@@ -36,7 +36,7 @@ module Edgeway
           FileUtils.chmod(0o755, dest) if File.executable?(src)
           puts "  create  #{dest}"
         end
-        puts "\nNext: cd #{@dir} && bin/setup && bundle exec edgeway test && bin/build"
+        puts "\nNext: cd #{@dir} && bin/setup && bin/test && bin/build"
       end
     end
   end

data/lib/edgeway/cli/test.rb

@@ -3,31 +3,50 @@
 module Edgeway
   module CLI
     class Test
+      PLATFORMS = []
+
       def self.run(args)
         root = Dir.pwd
-        Precheck.sqlite!
-        new(root).write_test_app
-        exec("spinel_test-unit", "-I", root, "-I", CLI.gem_dir + "/lib", *args)
+        database = Build::DatabaseConfig.new(root)
+        (PLATFORMS.find { |platform| platform.handles?(database) } || Test).new(root).run(args)
       end
 
       def initialize(root)
         @root = root
       end
 
+      def run(args)
+        Precheck.sqlite!
+        write_test_app
+        exec("spinel_test-unit", "-I", @root, "-I", CLI.gem_dir + "/lib", *args)
+      end
+
       def write_test_app
         raise Error, "no config/routes.rb in #{@root}" unless File.exist?(File.join(@root, "config/routes.rb"))
 
         FileUtils.mkdir_p(File.join(@root, "tmp"))
         lines = ["# Generated by `edgeway test` from app/ and config/; do not edit.", 'require "edgeway"']
-        lines << 'require "edgeway/db/memory"'
-        lines << 'require "edgeway/db/sqlite"'
-        # Where the migrations are read from at test time (the binary may run
-        # from another directory); Edgeway::UnitTest#setup applies them.
-        lines << "module Edgeway; TEST_APP_ROOT = #{@root.dump}; end"
+        lines.concat(database_lines)
         lines << ""
-        lines.concat(AppFiles.new(@root).require_lines)
+        views = Build::ViewCompiler.new(@root).compile
+        File.write(File.join(@root, "tmp/views.rb"), views) if views
+        lines.concat(Build::AppFiles.new(@root).require_lines(views: views && "views"))
         File.write(File.join(@root, "tmp/test_app.rb"), lines.join("\n") + "\n")
       end
+
+      private
+
+      def database_lines
+        [
+          'require "edgeway/db/memory"',
+          'require "edgeway/db/sqlite"',
+          'require "edgeway/test/sqlite_databases"',
+          # Where the migrations are read from at test time (the binary may run
+          # from another directory); Edgeway::TestDatabases applies them.
+          "module Edgeway; TEST_APP_ROOT = #{@root.dump}; end",
+          "module Edgeway; TEST_DATABASES = #{Build::DatabaseConfig.new(@root).names.inspect}; end"
+        ]
+      end
     end
   end
 end

data/lib/edgeway/cli/toolchain.rb

@@ -19,6 +19,11 @@ module Edgeway
         find_on_path("spinel") || mise_which("spinel")
       end
 
+      def self.wasi_sdk
+        dir = [ENV["WASI_SDK"], ENV["WASI_SDK_PATH"]].find { |value| !value.to_s.empty? } || "/opt/wasi-sdk"
+        File.directory?(dir) ? dir : nil
+      end
+
       def self.find_on_path(name)
         ENV["PATH"].to_s.split(File::PATH_SEPARATOR).map { |d| File.join(d, name) }
                    .find { |f| File.file?(f) && File.executable?(f) }

data/lib/edgeway/cli.rb

@@ -5,12 +5,11 @@
 require "fileutils"
 require "yaml"
 require_relative "version"
-require_relative "cli/app_config"
 require_relative "cli/toolchain"
-require_relative "cli/app_files"
 require_relative "cli/build"
 require_relative "cli/precheck"
 require_relative "cli/test"
+require_relative "cli/cloudflare_test"
 require_relative "cli/routes"
 require_relative "cli/package_manager"
 require_relative "cli/generate"
@@ -22,9 +21,13 @@ module Edgeway
       Usage: edgeway COMMAND [options]
 
         new APP                  create a new app in APP/
-        build [--env ENV]        compile the app to build/app.wasm (ENV: development)
+        build [--env ENV] [--release]
+                                 compile the app to build/app.wasm (ENV: development);
+                                   --release builds for deploying (no --incremental)
         test [ARGS]              regenerate tmp/test_app.rb, run test/ with spinel_test-unit
-        generate, g KIND NAME    generate a model (NAME field:type ...) or a controller (NAME action ...)
+                                   (natively, or as wasm on the platform's local database, by database.yml's test:)
+        generate, g KIND NAME    generate a model (NAME field:type ...), a controller (NAME action ...)
+                                   or a scaffold (NAME field:type ...)
         routes                   print the routes
         version                  print the version
     TEXT

data/lib/edgeway/controller/base.rb

@@ -5,15 +5,35 @@ module Edgeway
       include Rescuable
       include Rendering
       include Authentication
+      include Caching
+      include RateLimiting
 
       NON_ACTIONS = ["render", "head", "headers", "params", "request", "performed?", "to_response",
                      "action?", "run_before_actions", "rescue_with_handler",
-                     "authenticate!", "current_claims", "authenticated?"]
+                     "authenticate!", "current_claims", "authenticated?",
+                     "action_name", "action_name=", "raw",
+                     "expires_in", "no_store", "fresh_when", "stale?"]
 
       def self.before_action(name, only: [], except: [])
+        add_before_action(Callback.new(name, only.map(&:to_s), except.map(&:to_s)))
+      end
+
+      def self.rate_limit(binding_name, by: nil, name: nil, retry_after: nil, only: [], except: [])
+        add_before_action(RateLimiting::Rule.build(binding_name, by, name, retry_after, only, except))
+        (@own_non_actions ||= []) << by.to_s unless by.nil?
+      end
+
+      def self.own_non_actions = (@own_non_actions || [])
+
+      def self.non_action?(name)
+        lineage.any? { |c| c.own_non_actions.include?(name) }
+      end
+
+      def self.add_before_action(callback)
         @own_before_actions ||= []
-        @own_before_actions << Callback.new(name, only.map(&:to_s), except.map(&:to_s))
+        @own_before_actions << callback
       end
+      private_class_method :add_before_action
 
       def self.own_before_actions = (@own_before_actions || [])
 
@@ -48,9 +68,11 @@ module Edgeway
       end
 
       attr_reader :request
+      attr_accessor :action_name
 
       def initialize(request)
         @request = request
+        @action_name = ""
         @status = 200
         @headers = {}
         @response_body = ""
@@ -63,9 +85,16 @@ module Edgeway
       def headers = @headers
 
       def action?(name)
-        self.respond_to?(name.to_sym) && !NON_ACTIONS.include?(name)
+        return false if name.start_with?("_view_") || name.start_with?("_render_")
+        respond_to?(name.to_sym) && !NON_ACTIONS.include?(name) && !self.class.non_action?(name)
       end
 
+      def raw(text) = View::SafeHTML.new(text)
+
+      def _render_view(action) = nil
+
+      def _render_layout(content) = content
+
       def params
         @params ||= wrapped_params
       end