edgeway 0.1.0

data/lib/edgeway/routing/route_set.rb

@@ -0,0 +1,27 @@
+module Edgeway
+  module Routing
+    class RouteSet
+      attr_reader :list
+
+      def initialize
+        @list = []
+      end
+
+      def draw
+        yield Mapper.new(self, "", "")
+      end
+
+      def add(route)
+        @list << route
+      end
+
+      def recognize(verb, path)
+        @list.each do |route|
+          found = route.match(verb, path)
+          return [route, found] if found
+        end
+        raise RoutingError, "no route for #{verb} #{path}"
+      end
+    end
+  end
+end

data/lib/edgeway/server.rb

@@ -0,0 +1,12 @@
+module Edgeway
+  # Runs the app for one request, CGI style: the request comes in as CGI
+  # environment variables and STDIN (HTTP::Request.from_env), and the response
+  # goes out on stdout as CGI output (Status and the headers, a blank line,
+  # the body), which js/runtime.js turns into the Response.
+  module Server
+    def self.run
+      response = Edgeway.application.call(HTTP::Request.from_env)
+      print response.to_cgi
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# Cloudflare D1, through the wasm import module "edgeway_d1" that
+# js/cloudflare.js implements. Only wasm builds load this file: ffi_source is
+# Spinel's, so CRuby can't read it (tests use edgeway/db/memory).
+require "json"
+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
+    # 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}, ...]}
+    #   any         {"error": "message"} when D1 failed
+    #
+    # 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
+    # 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("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;
+        }
+
+        /* 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));
+        }
+
+        const char *d1_execute(const char *binding, const char *sql, const char *binds) {
+          return take_result(js_d1_execute(binding, sql, binds));
+        }
+
+        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_batch, [:str, :str], :str
+    end
+
+    class D1Adapter < DB::Adapter
+      # binding: the name of the D1 binding in wrangler.toml.
+      def initialize(binding: "DB")
+        @binding_name = binding
+      end
+
+      def select_all(sql, binds)
+        result(D1Imports.d1_query(@binding_name, sql, JSON.generate(binds)))["rows"]
+      end
+
+      def execute(sql, 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 }
+      end
+
+      # One D1 batch(): the statements run as a single transaction, so any
+      # failure rolls all of them back.
+      def batch(statements)
+        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 } }
+      end
+
+      private
+
+      def result(json)
+        res = JSON.parse(json)
+        fail_with("d1: #{res["error"]}") if res.key?("error")
+        res
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# JWT signature checks on Cloudflare Workers, through the wasm import module
+# "edgeway_jwt" that js/jwt.js implements. Only wasm builds load this file
+# (ffi_source is Spinel's; tests use edgeway/http/auth/stub).
+require "json"
+require_relative "../../http/auth/jwt"
+
+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;
+
+        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;
+        }
+      C
+      ffi_func :jwt_verify, [:str], :str
+    end
+
+    class JWTVerifier < Auth::Verifier
+      def verify(token)
+        JWTImports.jwt_verify(token)
+      end
+    end
+  end
+end

data/lib/edgeway/test.rb

@@ -0,0 +1,97 @@
+# Test helper (Edgeway::UnitTest for models, Edgeway::IntegrationTest for requests): `require "edgeway/test"` in test/test_helper.rb.
+# Needs spinel_test-unit (a development dependency of the app, not of edgeway)
+# and tmp/test_app.rb, which `edgeway test` rewrites on every run (and which
+# is git-ignored): Spinel resolves require
+# at compile time, so the app's files are listed there (in Build's order)
+# rather than found at run time. Unlike build/main.rb it never calls
+# Edgeway::Server.run. Run the tests with `edgeway test`, not spinel_test-unit
+# directly: a missing or stale tmp/test_app.rb only shows up as Spinel's own
+# "cannot find tmp/test_app" (the message cannot be customised at compile time).
+require "spinel_test/unit"
+require "edgeway"
+require "edgeway/db/memory"
+require "edgeway/db/sqlite"
+require "tmp/test_app"
+
+module Edgeway
+  # What a test sees of the answer.
+  class TestResponse
+    attr_reader :status, :body, :headers
+
+    def initialize(status, body, headers)
+      @status = status
+      @body = body
+      @headers = headers
+    end
+  end
+
+  # 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.
+  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
+    end
+
+    def teardown
+      @db.close
+    end
+  end
+
+  # A UnitTest that also sends requests to the app (get, post, ...) and reads
+  # the answer (response, json, assert_response).
+  class IntegrationTest < UnitTest
+    attr_reader :response
+
+    def setup
+      super
+      @response = nil
+      @json = nil
+    end
+
+    def get(path, json: nil, headers: {}) = request("GET", path, json, headers)
+    def delete(path, json: nil, headers: {}) = request("DELETE", path, json, headers)
+    def post(path, json: nil, headers: {}) = request("POST", path, json, headers)
+    def put(path, json: nil, headers: {}) = request("PUT", path, json, headers)
+    def patch(path, json: nil, headers: {}) = request("PATCH", path, json, headers)
+
+    # The body parsed as JSON.
+    def json
+      @json = JSON.parse(@response.body) if @json.nil?
+      @json
+    end
+
+    def assert_response(status)
+      assert_equal status, @response.status
+    end
+
+    private
+
+    def request(verb, target, json, headers)
+      path = target
+      query = ""
+      q = target.index("?")
+      unless q.nil?
+        path = target[0, q]
+        query = target[q + 1, target.length]
+      end
+      body = json.nil? ? "" : JSON.generate(json)
+      content_type = json.nil? ? "" : "application/json"
+      headers.each { |k, v| ENV["HTTP_" + k.upcase.gsub("-", "_")] = v }
+      begin
+        res = Edgeway.application.call(Edgeway::HTTP::Request.new(verb, path, query, content_type, body))
+      ensure
+        headers.each { |k, _v| ENV.delete("HTTP_" + k.upcase.gsub("-", "_")) }
+      end
+      @json = nil
+      @response = Edgeway::TestResponse.new(res.status, res.body, res.headers)
+      @response
+    end
+  end
+end

data/lib/edgeway/version.rb

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

data/lib/edgeway.rb

@@ -0,0 +1,30 @@
+require "json"
+require "time"
+require_relative "edgeway/version"
+require_relative "edgeway/errors"
+require_relative "edgeway/inflector"
+require_relative "edgeway/config"
+require_relative "edgeway/logger"
+require_relative "edgeway/http/response"
+require_relative "edgeway/http/parameters"
+require_relative "edgeway/http/json_body"
+require_relative "edgeway/http/request"
+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/attributes"
+require_relative "edgeway/model/validations"
+require_relative "edgeway/model/macros"
+require_relative "edgeway/model/relation"
+require_relative "edgeway/model/persistence"
+require_relative "edgeway/model/base"
+require_relative "edgeway/http/auth/jwt"
+require_relative "edgeway/controller/callbacks"
+require_relative "edgeway/controller/rescuable"
+require_relative "edgeway/controller/rendering"
+require_relative "edgeway/controller/authentication"
+require_relative "edgeway/controller/base"
+require_relative "edgeway/controller/dispatcher"
+require_relative "edgeway/application"
+require_relative "edgeway/server"

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: edgeway
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yuji Yaginuma
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+email:
+- yuuji.yaginuma@gmail.com
+executables:
+- edgeway
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- exe/edgeway
+- js/cgi.js
+- js/cloudflare.js
+- js/cors.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/generate.rb
+- lib/edgeway/cli/new.rb
+- lib/edgeway/cli/package_manager.rb
+- lib/edgeway/cli/precheck.rb
+- lib/edgeway/cli/routes.rb
+- lib/edgeway/cli/test.rb
+- lib/edgeway/cli/toolchain.rb
+- lib/edgeway/config.rb
+- lib/edgeway/controller/authentication.rb
+- lib/edgeway/controller/base.rb
+- lib/edgeway/controller/callbacks.rb
+- lib/edgeway/controller/dispatcher.rb
+- lib/edgeway/controller/rendering.rb
+- lib/edgeway/controller/rescuable.rb
+- lib/edgeway/db/adapter.rb
+- lib/edgeway/db/memory.rb
+- lib/edgeway/db/sqlite.rb
+- lib/edgeway/errors.rb
+- lib/edgeway/generators/app/templates/.gitignore
+- 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/bin/build.tt
+- lib/edgeway/generators/app/templates/bin/deploy.tt
+- lib/edgeway/generators/app/templates/bin/setup.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
+- lib/edgeway/generators/app/templates/mise.toml.tt
+- lib/edgeway/generators/app/templates/package.json.tt
+- lib/edgeway/generators/app/templates/src/worker.js
+- lib/edgeway/generators/app/templates/test/controllers/health_test.rb
+- lib/edgeway/generators/app/templates/test/test_helper.rb
+- lib/edgeway/generators/app/templates/wrangler.toml.tt
+- lib/edgeway/http/auth/jwt.rb
+- lib/edgeway/http/auth/stub.rb
+- lib/edgeway/http/json_body.rb
+- lib/edgeway/http/parameters.rb
+- lib/edgeway/http/request.rb
+- lib/edgeway/http/response.rb
+- lib/edgeway/inflector.rb
+- lib/edgeway/logger.rb
+- lib/edgeway/model/attributes.rb
+- lib/edgeway/model/base.rb
+- lib/edgeway/model/macros.rb
+- lib/edgeway/model/persistence.rb
+- lib/edgeway/model/relation.rb
+- lib/edgeway/model/validations.rb
+- lib/edgeway/routing/mapper.rb
+- lib/edgeway/routing/route.rb
+- lib/edgeway/routing/route_set.rb
+- lib/edgeway/server.rb
+- lib/edgeway/service/cloudflare/d1.rb
+- lib/edgeway/service/cloudflare/jwt.rb
+- lib/edgeway/test.rb
+- lib/edgeway/version.rb
+homepage: https://github.com/y-yagi/edgeway
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/y-yagi/edgeway
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.17
+specification_version: 4
+summary: A library for Ruby compiled by Spinel to wasm on edge workers.
+test_files: []