edgeway 0.1.0

data/lib/edgeway/cli/precheck.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+require "shellwords"
+
+module Edgeway
+  module CLI
+    module Precheck
+      def self.sqlite!
+        return if ENV["EDGEWAY_SKIP_PRECHECK"] == "1"
+
+        cc = compiler
+        return if cc.nil? || sqlite_links?(cc)
+
+        raise Error, <<~MSG.chomp
+          libsqlite3 cannot be linked (`#{cc.join(" ")} -lsqlite3` failed); `edgeway test` needs the SQLite development library.
+            Debian/Ubuntu: sudo apt install libsqlite3-dev
+            Fedora:        sudo dnf install sqlite-devel
+            macOS:         brew install sqlite
+          If it is installed somewhere else, set LIBRARY_PATH to a directory holding libsqlite3.so.
+          Set EDGEWAY_SKIP_PRECHECK=1 to skip this check.
+        MSG
+      end
+
+      # The compiler command as an argv array, or nil when there is none.
+      def self.compiler
+        env = ENV["CC"].to_s.strip
+        unless env.empty?
+          argv = Shellwords.split(env)
+          return argv if !argv.empty? && (argv[0].include?("/") ? File.executable?(argv[0]) : Toolchain.find_on_path(argv[0]))
+        end
+        %w[cc gcc clang].each { |n| return [n] if Toolchain.find_on_path(n) }
+        nil
+      end
+
+      def self.sqlite_links?(cc)
+        Dir.mktmpdir("edgeway-precheck") do |dir|
+          src = File.join(dir, "t.c")
+          File.write(src, "int main(){return 0;}\n")
+          system(*cc, src, "-o", File.join(dir, "t"), "-lsqlite3", out: File::NULL, err: File::NULL) ? true : false
+        end
+      end
+    end
+  end
+end

data/lib/edgeway/cli/routes.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Edgeway
+  module CLI
+    class Routes
+      def self.run(_args)
+        path = File.join(Dir.pwd, "config/routes.rb")
+        raise Error, "no config/routes.rb in #{Dir.pwd}" unless File.exist?(path)
+
+        $LOAD_PATH.unshift(File.join(CLI.gem_dir, "lib"))
+        require "edgeway"
+        load path
+        list = Edgeway.application.routes.list
+        verb_w = list.map { |r| r.verb.size }.max.to_i
+        path_w = list.map { |r| r.pattern.size }.max.to_i
+        list.each do |r|
+          puts "#{r.verb.ljust(verb_w)}  #{r.pattern.ljust(path_w)}  #{r.controller_path}##{r.action}"
+        end
+      end
+    end
+  end
+end

data/lib/edgeway/cli/test.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Edgeway
+  module CLI
+    class Test
+      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)
+      end
+
+      def initialize(root)
+        @root = root
+      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 << ""
+        lines.concat(AppFiles.new(@root).require_lines)
+        File.write(File.join(@root, "tmp/test_app.rb"), lines.join("\n") + "\n")
+      end
+    end
+  end
+end

data/lib/edgeway/cli/toolchain.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Edgeway
+  module CLI
+    # Finds the Spinel compiler, for `edgeway build` and the Rakefile.
+    #
+    #   1. SPINEL (a Spinel checkout, for example)
+    #   2. spinel on PATH (mise puts its spinel there when it is activated)
+    #   3. `mise which spinel` (mise is installed but not activated)
+    #
+    # The WASI SDK that --target=wasm32-wasi needs is Spinel's to find: it
+    # reads WASI_SDK (mise.toml sets it), then WASI_SDK_PATH, and defaults to
+    # /opt/wasi-sdk.
+    module Toolchain
+      def self.spinel
+        env = ENV["SPINEL"]
+        return env unless env.nil? || env.empty?
+
+        find_on_path("spinel") || mise_which("spinel")
+      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) }
+      end
+
+      def self.mise_which(name)
+        return nil unless find_on_path("mise")
+
+        out = IO.popen(["mise", "which", name], err: File::NULL, &:read).strip
+        $?.success? && !out.empty? ? out : nil
+      end
+    end
+  end
+end

data/lib/edgeway/cli.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+# The edgeway command (CRuby). Not part of the wasm: lib/edgeway.rb does not
+# require it.
+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/routes"
+require_relative "cli/package_manager"
+require_relative "cli/generate"
+require_relative "cli/new"
+
+module Edgeway
+  module CLI
+    USAGE = <<~TEXT
+      Usage: edgeway COMMAND [options]
+
+        new APP                  create a new app in APP/
+        build [--env ENV]        compile the app to build/app.wasm (ENV: development)
+        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 ...)
+        routes                   print the routes
+        version                  print the version
+    TEXT
+
+    class Error < StandardError; end
+
+    # The directory of the gem: lib/ is what Spinel gets as -I, js/ is
+    # copied into the app's build/.
+    def self.gem_dir
+      File.expand_path("../..", __dir__)
+    end
+
+    def self.start(argv)
+      command, *args = argv
+      case command
+      when "new" then New.run(args)
+      when "build" then Build.run(args)
+      when "test" then Test.run(args)
+      when "generate", "g" then Generate.run(args)
+      when "routes" then Routes.run(args)
+      when "version", "-v", "--version" then puts "edgeway #{Edgeway::VERSION}"
+      when nil, "help", "-h", "--help" then puts USAGE
+      else
+        warn "edgeway: unknown command #{command}\n\n#{USAGE}"
+        exit 1
+      end
+    rescue Error => e
+      warn "edgeway: #{e.message}"
+      exit 1
+    end
+  end
+end

data/lib/edgeway/config.rb

@@ -0,0 +1,9 @@
+module Edgeway
+  def self.env
+    ENV["EDGEWAY_ENV"] || "development"
+  end
+
+  def self.config(name, default = "")
+    ENV[name] || default
+  end
+end

data/lib/edgeway/controller/authentication.rb

@@ -0,0 +1,42 @@
+module Edgeway
+  module Controller
+    # Bearer-token authentication:
+    #
+    #   class ApplicationController < Edgeway::Controller::Base
+    #     before_action :authenticate!
+    #   end
+    #   # or before_action :authenticate!, only: [:create]
+    #
+    # authenticate! answers 401 unless the request has an
+    # "Authorization: Bearer <JWT>" whose token passes Edgeway::Auth; the
+    # claims are then in current_claims.
+    module Authentication
+      # Raises Unauthorized (no token) or InvalidToken. Both are 401 with a
+      # WWW-Authenticate header, unless the app rescue_froms them.
+      def authenticate!
+        token = bearer_token
+        raise Unauthorized, "authentication required" if token.empty?
+        @current_claims = Auth.decode(token)
+        @authenticated = true
+        nil
+      end
+
+      # The token's claims (a Hash of the JSON payload), {} when the request
+      # was not authenticated.
+      def current_claims
+        @authenticated ? @current_claims : {}
+      end
+
+      def authenticated? = @authenticated
+
+      private
+
+      def bearer_token
+        value = @request.header("Authorization")
+        scheme = "Bearer "
+        return "" unless value.length > scheme.length && value[0, scheme.length].downcase == "bearer "
+        value[scheme.length, value.length - scheme.length].strip
+      end
+    end
+  end
+end

data/lib/edgeway/controller/base.rb

@@ -0,0 +1,95 @@
+module Edgeway
+  module Controller
+    class Base
+      include Callbacks
+      include Rescuable
+      include Rendering
+      include Authentication
+
+      NON_ACTIONS = ["render", "head", "headers", "params", "request", "performed?", "to_response",
+                     "action?", "run_before_actions", "rescue_with_handler",
+                     "authenticate!", "current_claims", "authenticated?"]
+
+      def self.before_action(name, only: [], except: [])
+        @own_before_actions ||= []
+        @own_before_actions << Callback.new(name, only.map(&:to_s), except.map(&:to_s))
+      end
+
+      def self.own_before_actions = (@own_before_actions || [])
+
+      def self.rescue_from(error_class, with:)
+        @own_handlers ||= []
+        @own_handlers << Handler.new(error_class, with)
+      end
+
+      def self.own_handlers = (@own_handlers || [])
+
+      def self.lineage
+        chain = []
+        k = self
+        while k
+          chain.unshift(k)
+          break if k == Base
+          k = k.superclass
+        end
+        chain
+      end
+
+      def self.all_before_actions
+        all = []
+        lineage.each { |c| c.own_before_actions.each { |cb| all << cb } }
+        all
+      end
+
+      def self.all_handlers
+        all = []
+        lineage.each { |c| c.own_handlers.each { |h| all << h } }
+        all
+      end
+
+      attr_reader :request
+
+      def initialize(request)
+        @request = request
+        @status = 200
+        @headers = {}
+        @response_body = ""
+        @performed = false
+        @params = nil
+        @current_claims = {}
+        @authenticated = false
+      end
+
+      def headers = @headers
+
+      def action?(name)
+        self.respond_to?(name.to_sym) && !NON_ACTIONS.include?(name)
+      end
+
+      def params
+        @params ||= wrapped_params
+      end
+
+      private
+
+      def wrapped_params
+        all = @request.params
+        scope = self.class.param_scope
+        prefix = "#{scope}["
+        return all unless @request.json?
+        return all if @request.body_params.keys.any? { |k| k.start_with?(prefix) }
+        wrapped = HTTP::Parameters.new(all.to_h.dup)
+        @request.body_params.each do |k, v|
+          wrapped["#{scope}[#{k}]"] = v unless k.include?("[")
+        end
+        wrapped
+      end
+
+      def self.param_scope
+        base = name.split("::").last.sub(/Controller\z/, "")
+        base = base.gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
+        Inflector.singularize(base)
+      end
+    end
+  end
+end

data/lib/edgeway/controller/callbacks.rb

@@ -0,0 +1,29 @@
+module Edgeway
+  module Controller
+    class Callback
+      attr_reader :name
+
+      def initialize(name, only, except)
+        @name = name
+        @only = only
+        @except = except
+      end
+
+      def applies?(action)
+        return false if @except.include?(action)
+        @only.empty? || @only.include?(action)
+      end
+    end
+
+    module Callbacks
+      def run_before_actions(action)
+        self.class.all_before_actions.each do |callback|
+          next unless callback.applies?(action)
+          send(callback.name)
+          return false if performed?
+        end
+        true
+      end
+    end
+  end
+end

data/lib/edgeway/controller/dispatcher.rb

@@ -0,0 +1,39 @@
+module Edgeway
+  module Controller
+    module Dispatcher
+      def self.controller_class(route)
+        klass = nil
+        begin
+          klass = Object.const_get(route.controller_class_name)
+        rescue NameError
+          return nil
+        end
+        klass.is_a?(Class) && klass < Base ? klass : nil
+      end
+
+      def self.dispatch(route, request)
+        klass = controller_class(route)
+        raise RoutingError, "no controller for #{route.controller_path}" if klass.nil?
+        controller = klass.new(request)
+        # A route whose action isn't defined (or is one of Base's own public
+        # methods) is a 404, as in Rails.
+        raise RoutingError, "no route for #{request.method} #{request.path}" unless controller.action?(route.action)
+        begin
+          # The action is called here, on an instance of a class found by
+          # name, and not from a Base method: with a name taken as a method
+          # argument Spinel's send looks among the literals of the program,
+          # and misses a subclass's methods (matz/spinel#8592). public_send:
+          # a route can't reach a private method.
+          action = route.action.to_sym
+          controller.public_send(action) if controller.run_before_actions(route.action)
+          controller.head(:no_content) unless controller.performed?
+        rescue => e
+          raise e unless controller.rescue_with_handler(e)
+          # A handler that rendered nothing answers 204, as an action does.
+          controller.head(:no_content) unless controller.performed?
+        end
+        controller.to_response
+      end
+    end
+  end
+end

data/lib/edgeway/controller/rendering.rb

@@ -0,0 +1,65 @@
+module Edgeway
+  module Controller
+    module Rendering
+      STATUS_CODES = {
+        "ok" => 200, "created" => 201, "accepted" => 202, "no_content" => 204,
+        "moved_permanently" => 301, "found" => 302, "not_modified" => 304,
+        "bad_request" => 400, "unauthorized" => 401, "forbidden" => 403, "not_found" => 404,
+        "method_not_allowed" => 405, "conflict" => 409, "unprocessable_entity" => 422,
+        "too_many_requests" => 429, "internal_server_error" => 500, "not_implemented" => 501,
+        "service_unavailable" => 503
+      }
+
+      def self.json_response(status, json_text)
+        HTTP::Response.json(status, json_text)
+      end
+
+      def self.status_code(status)
+        return status if status.is_a?(Integer)
+        code = STATUS_CODES[status.to_s]
+        raise ArgumentError, "unknown status: #{status.inspect}" if code.nil?
+        code
+      end
+
+      def self.json_value(obj)
+        if obj.is_a?(Model::Relation)
+          obj.to_a.map { |m| m.as_json }
+        elsif obj.is_a?(Model::Base)
+          obj.as_json
+        elsif obj.is_a?(HTTP::Parameters)
+          obj.to_h
+        elsif obj.is_a?(Array)
+          obj.map { |x| json_value(x) }
+        elsif obj.is_a?(Hash)
+          h = {}
+          obj.each { |k, v| h[k] = json_value(v) }
+          h
+        else
+          obj
+        end
+      end
+
+      def render(json:, status: 200)
+        @status = Rendering.status_code(status)
+        @headers["Content-Type"] = "application/json"
+        @response_body = JSON.generate(Rendering.json_value(json)) + "\n"
+        @performed = true
+      end
+
+      def head(status)
+        @status = Rendering.status_code(status)
+        @response_body = ""
+        @performed = true
+      end
+
+      def performed? = @performed
+
+      def to_response
+        response = HTTP::Response.new(@status, @response_body)
+        @headers.each { |k, v| response.headers[k] = v }
+        response.check_headers
+        response
+      end
+    end
+  end
+end

data/lib/edgeway/controller/rescuable.rb

@@ -0,0 +1,26 @@
+module Edgeway
+  module Controller
+    class Handler
+      attr_reader :error_class, :method_name
+
+      def initialize(error_class, method_name)
+        @error_class = error_class
+        @method_name = method_name
+      end
+    end
+
+    module Rescuable
+      # true when a handler took the error. The handler is called with the
+      # error, as in Rails (def not_found(e)).
+      def rescue_with_handler(error)
+        self.class.all_handlers.reverse.each do |handler|
+          if error.is_a?(handler.error_class)
+            send(handler.method_name, error)
+            return true
+          end
+        end
+        false
+      end
+    end
+  end
+end

data/lib/edgeway/db/adapter.rb

@@ -0,0 +1,32 @@
+module Edgeway
+  module DB
+    class Adapter
+      def select_all(sql, binds)
+        raise Error, "#{self.class} does not define select_all"
+      end
+
+      def execute(sql, binds)
+        raise Error, "#{self.class} does not define execute"
+      end
+
+      def batch(statements)
+        raise Error, "#{self.class} does not define batch"
+      end
+
+      def insert_returning(sql, binds)
+        rows = select_all(sql, binds)
+        raise DatabaseError, "INSERT ... RETURNING answered no row" if rows.empty?
+        rows[0]
+      end
+
+      def fail_with(message)
+        raise RecordNotUnique, message if message.include?("UNIQUE constraint failed")
+        raise DatabaseError, message
+      end
+
+      def supports_returning? = true
+      def placeholder(n) = "?"
+      def quote_boolean(value) = value ? 1 : 0
+    end
+  end
+end

data/lib/edgeway/db/memory.rb

@@ -0,0 +1,73 @@
+require_relative "adapter"
+
+module Edgeway
+  module DB
+    # An adapter for tests: it records the SQL it is given and answers the
+    # rows the test queued (none: an empty answer). Nothing is stored.
+    #
+    #   db = Edgeway::DB::MemoryAdapter.new
+    #   Edgeway::Model.connection = db
+    #   db.queue([{ "id" => 1, "title" => "a" }])
+    #   Todo.find(1)
+    #   puts db.log      # SELECT ... | [1]
+    class MemoryAdapter < Adapter
+      attr_reader :log
+      attr_writer :returning
+      # The "changes" count execute answers (1 by default), for delete_all.
+      attr_writer :changes
+
+      def initialize
+        @log = []
+        @queue = []
+        @returning = true
+        @changes = 1
+        @failure = nil
+        @failure_on = ""
+        @next_id = 1
+      end
+
+      # The rows the next query answers (one queue entry per query).
+      def queue(rows)
+        @queue << rows
+      end
+
+      # Makes the next query or execute whose SQL contains `containing` (any,
+      # by default) fail with this database message, after logging it, as D1
+      # would: "UNIQUE constraint failed: t.c" is a RecordNotUnique.
+      def fail_next(message, containing = "")
+        @failure = message
+        @failure_on = containing
+      end
+
+      def supports_returning? = @returning
+
+      def select_all(sql, binds)
+        record(sql, binds)
+        @queue.empty? ? [] : @queue.shift
+      end
+
+      def execute(sql, binds)
+        record(sql, binds)
+        id = @next_id
+        @next_id += 1
+        { "changes" => @changes, "last_insert_id" => id }
+      end
+
+      def batch(statements)
+        @log << "BATCH #{statements.size}"
+        statements.map { |s| execute(s[0], s[1]) }
+      end
+
+      private
+
+      def record(sql, binds)
+        @log << "#{sql} | #{JSON.generate(binds)}"
+        if !@failure.nil? && sql.include?(@failure_on)
+          message = @failure
+          @failure = nil
+          fail_with(message)
+        end
+      end
+    end
+  end
+end