edgeway 0.1.0

data/lib/edgeway/http/parameters.rb

@@ -0,0 +1,42 @@
+module Edgeway
+  module HTTP
+    class Parameters
+      # permitted: whether the values may be mass-assigned to a model. Only
+      # what permit returns is; the request's params are not.
+      def initialize(values = {}, permitted = false)
+        @values = values
+        @permitted = permitted
+      end
+
+      def permitted? = @permitted
+
+      def [](key) = @values[key.to_s]
+      def []=(key, value)
+        @values[key.to_s] = value
+      end
+      def key?(key) = @values.key?(key.to_s)
+      def fetch(key, default) = @values.key?(key.to_s) ? @values[key.to_s] : default
+      def empty? = @values.empty?
+      def to_h = @values
+
+      def require(scope)
+        prefix = "#{scope}["
+        found = {}
+        @values.each do |k, v|
+          found[k[prefix.length...-1]] = v if k.start_with?(prefix) && k.end_with?("]")
+        end
+        raise ParameterMissing, "param is missing or the value is empty: #{scope}" if found.empty?
+        Parameters.new(found)
+      end
+
+      def permit(*keys)
+        found = {}
+        keys.each do |key|
+          name = key.to_s
+          found[name] = @values[name] if @values.key?(name)
+        end
+        Parameters.new(found, true)
+      end
+    end
+  end
+end

data/lib/edgeway/http/request.rb

@@ -0,0 +1,115 @@
+module Edgeway
+  module HTTP
+    class Request
+      REPLACEMENT = "\uFFFD"
+
+      attr_reader :method, :path, :query_string, :content_type, :body, :params, :body_params
+
+      def self.from_env
+        new(ENV["REQUEST_METHOD"] || "GET", ENV["PATH_INFO"] || "/", ENV["QUERY_STRING"] || "",
+            ENV["CONTENT_TYPE"] || "", STDIN.read || "")
+      end
+
+      def initialize(method, path, query_string, content_type, body)
+        @method = method
+        @path = path
+        @query_string = query_string
+        @content_type = content_type
+        @body = body
+        @params = Parameters.new({})
+        @body_params = {}
+        @json_body = nil
+      end
+
+      def header(name)
+        ENV["HTTP_" + name.upcase.gsub("-", "_")] || ""
+      end
+
+      def json?
+        @content_type.start_with?("application/json")
+      end
+
+      def form?
+        @content_type.start_with?("application/x-www-form-urlencoded")
+      end
+
+      def json_body
+        @json_body
+      end
+
+      def read_body
+        read_query
+        return if @body.empty?
+        raise BadRequest, "body is not valid UTF-8" unless @body.valid_encoding?
+        if json?
+          read_json
+        elsif form?
+          read_form
+        end
+      end
+
+      def add_path_params(path_params)
+        path_params.each { |k, v| @params[k] = v }
+      end
+
+      private
+
+      def read_query
+        return if @query_string.empty?
+        decode_pairs(@query_string, "query string").each { |k, v| @params[k] = v }
+      end
+
+      def read_form
+        add_body_params(decode_pairs(@body, "form body"))
+      end
+
+      # decode_www_form never raises on bad bytes: it turns those that aren't
+      # UTF-8 (%ff) into U+FFFD. That is only right when the client sent a
+      # U+FFFD itself, so otherwise one in the result is a BadRequest.
+      def decode_pairs(text, what)
+        raise BadRequest, "#{what} is not valid UTF-8" unless text.valid_encoding?
+        pairs = decode_www_form(text)
+        sent = text.include?(REPLACEMENT) || text.downcase.include?("%ef%bf%bd")
+        unless sent
+          pairs.each do |k, v|
+            raise BadRequest, "#{what} is not valid UTF-8" if k.include?(REPLACEMENT) || v.include?(REPLACEMENT)
+          end
+        end
+        pairs
+      end
+
+      # URI.decode_www_form, written out so that Edgeway doesn't require
+      # "uri": a send with a computed name (Dispatcher) reaches uri's
+      # find_proxy(env = ENV), which Spinel refuses since its Strings are
+      # shared by reference (matz/spinel 44119ab30). Same answers as uri's,
+      # ArgumentError for a non-ASCII input included.
+      def decode_www_form(text)
+        raise ArgumentError, "the input of URI.decode_www_form must be ASCII only string" unless text.ascii_only?
+        return [] if text.empty?
+        pieces = text.split("&", -1)
+        pieces.pop if pieces.last.empty?
+        pieces.map do |piece|
+          key, _sep, val = piece.partition("=")
+          [unescape_www(key), unescape_www(val)]
+        end
+      end
+
+      def unescape_www(s)
+        s.b.gsub(/\+|%\h\h/) { |m| m == "+" ? " " : m[1, 2].hex.chr }.force_encoding(Encoding::UTF_8).scrub
+      end
+
+      def read_json
+        json = JSONBody.new(@body)
+        @json_body = json.value
+        add_body_params(json.params)
+      end
+
+      def add_body_params(pairs)
+        pairs.each do |k, v|
+          @params[k] = v
+          @body_params[k] = v
+        end
+      end
+    end
+  end
+end

data/lib/edgeway/http/response.rb

@@ -0,0 +1,46 @@
+module Edgeway
+  module HTTP
+    class Response
+      # The characters of an HTTP token (RFC 9110), which is what a header
+      # name is.
+      TOKEN = /\A[A-Za-z0-9!#$%&'*+.^_`|~-]+\z/
+
+      attr_accessor :status, :body
+      attr_reader :headers
+
+      def initialize(status = 200, body = "")
+        @status = status
+        @headers = {}
+        @body = body
+      end
+
+      def self.json(status, json_text)
+        response = new(status, json_text + "\n")
+        response.headers["Content-Type"] = "application/json"
+        response.headers["X-Content-Type-Options"] = "nosniff"
+        response
+      end
+
+      # Raises InvalidHeader unless every header name is an HTTP token and no
+      # value holds CR, LF or NUL: js/cgi.js reads each line of to_cgi as a
+      # header, so a newline in a value would let a client add headers, a
+      # second Status or the body (headers["X-Name"] = params["name"]).
+      def check_headers
+        @headers.each do |k, v|
+          raise InvalidHeader, "bad header name: #{k.to_s.inspect}" unless TOKEN.match?(k.to_s)
+          text = v.to_s
+          if text.include?("\n") || text.include?("\r") || text.include?("\0")
+            raise InvalidHeader, "bad value for header #{k}"
+          end
+        end
+      end
+
+      def to_cgi
+        check_headers
+        out = "Status: #{@status}\n"
+        @headers.each { |k, v| out += "#{k}: #{v}\n" }
+        out + "\n" + @body
+      end
+    end
+  end
+end

data/lib/edgeway/inflector.rb

@@ -0,0 +1,16 @@
+module Edgeway
+  module Inflector
+    def self.singularize(name)
+      n = name.to_s
+      return n[0...-3] + "y" if n.end_with?("ies")
+      return n[0...-1] if n.end_with?("s")
+      n
+    end
+
+    def self.pluralize(name)
+      n = name.to_s
+      return n[0...-1] + "ies" if n.end_with?("y") && n.length > 1 && !"aeiou".include?(n[-2])
+      n + "s"
+    end
+  end
+end

data/lib/edgeway/logger.rb

@@ -0,0 +1,21 @@
+module Edgeway
+  # Writes to stderr; the runtime sends it to console.error.
+  class Logger
+    def info(message)
+      STDERR.puts "[edgeway] #{message}"
+    end
+
+    def error(message)
+      STDERR.puts "[edgeway] ERROR #{message}"
+    end
+  end
+
+  def self.logger
+    @logger ||= Logger.new
+  end
+
+  # For tests that want to see what is logged.
+  def self.logger=(logger)
+    @logger = logger
+  end
+end

data/lib/edgeway/model/attributes.rb

@@ -0,0 +1,85 @@
+module Edgeway
+  module Model
+    TRUE_STRINGS = ["true", "1", "t", "on"]
+
+    # Integer is 32-bit in a wasm build: to_i raises RangeError beyond these.
+    # to_int checks them too, so CRuby and a native build (64-bit) cast the
+    # same values to nil as the wasm does.
+    INT_MAX = 2147483647
+    INT_MIN = -2147483648
+
+    def self.connection=(adapter)
+      @connection = adapter
+    end
+
+    def self.connection
+      @connection || raise(ConfigurationError, "Edgeway::Model.connection is not set")
+    end
+
+    # Runs the block with writes queued instead of executed, then sends them
+    # all as one atomic batch (D1 batch(): one SQL transaction, all or none).
+    def self.batch
+      if @batch_queue
+        yield
+        return []
+      end
+      queue = []
+      @batch_queue = queue
+      begin
+        yield
+      rescue => e
+        @batch_queue = nil
+        raise e
+      end
+      @batch_queue = nil
+      queue.empty? ? [] : connection.batch(queue)
+    end
+
+    def self.batching? = !@batch_queue.nil?
+
+    # Every model write but an INSERT goes through here: executed at once, or
+    # queued inside batch. A queued write answers a placeholder result, as its
+    # counts are not known until the batch is sent.
+    def self.write(sql, binds)
+      queue = @batch_queue
+      if queue.nil?
+        connection.execute(sql, binds)
+      else
+        queue << [sql, binds]
+        { "changes" => 0, "last_insert_id" => 0 }
+      end
+    end
+
+    def self.to_int(v)
+      n = v.is_a?(Integer) ? v : v.to_s.to_i
+      n > INT_MAX || n < INT_MIN ? nil : n
+    rescue RangeError
+      nil
+    end
+
+    def self.cast(type, v)
+      return nil if v.nil?
+      case type
+      when :integer then to_int(v)
+      when :float then v.is_a?(Float) ? v : v.to_s.to_f
+      when :boolean then v == true || TRUE_STRINGS.include?(v.to_s)
+      else v.to_s
+      end
+    end
+
+    def self.to_db(v)
+      return connection.quote_boolean(v) if v == true || v == false
+      v
+    end
+
+    def self.underscore(name)
+      name.gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
+    end
+
+    def self.now = @frozen_time || Time.now.utc.iso8601(3)
+
+    def self.freeze_time(text)
+      @frozen_time = text
+    end
+  end
+end

data/lib/edgeway/model/base.rb

@@ -0,0 +1,173 @@
+module Edgeway
+  module Model
+    class Base
+      include Persistence
+      include Validations
+
+      # The model an association name ("comments", "todo") stands for. owner is
+      # the full name of the model that declares it: the namespaces around the
+      # owner are tried first, innermost out ("Admin::Comment" for an
+      # Admin::Post), then the top level.
+      def self.model_named(name, owner = "")
+        base = Inflector.singularize(name).split("_").map(&:capitalize).join
+        scope = owner.split("::")
+        scope.pop
+        klass = nil
+        until klass || scope.empty?
+          klass = model_class((scope + [base]).join("::"))
+          scope.pop
+        end
+        klass ||= model_class(base)
+        raise ArgumentError, "no model for #{name}" if klass.nil?
+        klass
+      end
+
+      def self.model_class(full_name)
+        klass = nil
+        begin
+          klass = Object.const_get(full_name)
+        rescue NameError
+          return nil
+        end
+        klass.is_a?(Class) && klass < Base ? klass : nil
+      end
+
+      def self.table_name=(name)
+        @table_name = name
+      end
+
+      def self.table_name
+        @table_name || Inflector.pluralize(Model.underscore(name.split("::").last))
+      end
+
+      def self.attribute_types = (@attribute_types ||= {})
+      def self.attribute_defaults = (@attribute_defaults ||= {})
+      def self.belongs_to_list = (@belongs_to ||= [])
+      def self.keep_type(col)
+        @kept_types ||= {}
+        @kept_types[col] = attribute_types[col] if attribute_types.key?(col)
+      end
+
+      def self.restore_type(col)
+        @kept_types ||= {}
+        attribute_types[col] = @kept_types[col] if @kept_types.key?(col)
+      end
+
+      def self.rules = (@rules ||= [])
+      def self.has_manys = (@has_manys ||= [])
+
+      # The has_manys with a dependent: option.
+      def self.dependents = has_manys.reject { |h| h.mode.nil? }
+
+      def self.validates(*names, presence: false, length: nil, inclusion: nil, numericality: nil, format: nil, uniqueness: nil)
+        names.each do |n|
+          attr = n.to_s
+          rules << Rule.new(attr, "presence", {}, [], nil) if presence
+          rules << Rule.new(attr, "length", Rule.bounds(length), [], nil) unless length.nil?
+          rules << Rule.new(attr, "inclusion", {}, inclusion[:in].map(&:to_s), nil) unless inclusion.nil?
+          rules << Rule.new(attr, "numericality", Rule.bounds(numericality), [], nil) unless numericality.nil?
+          rules << Rule.new(attr, "format", {}, [], format[:with]) unless format.nil?
+          # The scope columns are in the list slot.
+          rules << Rule.new(attr, "uniqueness", {}, Rule.scope_columns(uniqueness), nil) unless uniqueness.nil? || uniqueness == false
+        end
+      end
+
+      def self.column(name)
+        col = name.to_s
+        raise UnknownColumn, "unknown column: #{col}" unless col == "id" || attribute_types.key?(col)
+        col
+      end
+
+      def self.columns
+        ["id"] + attribute_types.keys
+      end
+
+      def self.type_of(col)
+        col == "id" ? :integer : attribute_types[col]
+      end
+
+      def self.all = Relation.new(self)
+      def self.where(conditions) = all.where(conditions)
+      def self.order(col, dir = :asc) = all.order(col, dir)
+      def self.reorder(col, dir = :asc) = all.reorder(col, dir)
+      def self.delete_all = all.delete_all
+      def self.destroy_all = all.destroy_all
+      def self.eager_load(*names) = all.eager_load(*names)
+      def self.limit(n) = all.limit(n)
+      def self.offset(n) = all.offset(n)
+      def self.count = all.count
+      def self.exists?(conditions = {}) = all.where(conditions).exists?
+      def self.pluck(col) = all.pluck(col)
+      def self.first = all.first
+      def self.find_by(conditions) = all.find_by(conditions)
+      def self.find(id) = all.find(id)
+
+      def self.find_or_create_by(conditions) = all.find_or_create_by(conditions)
+      def self.find_or_create_by!(conditions) = all.find_or_create_by!(conditions)
+
+      def self.create(attrs = {})
+        record = new(attrs)
+        record.save
+        record
+      end
+
+      def self.create!(attrs = {})
+        record = new(attrs)
+        record.save!
+        record
+      end
+
+      def self.instantiate(row)
+        record = new({})
+        record.load_row(row)
+        record
+      end
+
+      def initialize(attrs = {})
+        @attributes = {}
+        @raw = {}
+        @errors = []
+        @persisted = false
+        @loaded_children = {}
+        @loaded_parents = {}
+        self.class.attribute_defaults.each { |k, v| write_attribute(k, v) }
+        assign(attrs)
+      end
+
+      def id = @attributes["id"]
+      def persisted? = @persisted
+      def new_record? = !@persisted
+
+      def assign(attrs)
+        if attrs.is_a?(HTTP::Parameters)
+          raise ForbiddenAttributes, "#{self.class.name}: params must go through permit" unless attrs.permitted?
+          values = attrs.to_h
+        else
+          values = attrs
+        end
+        types = self.class.attribute_types
+        values.each do |k, v|
+          key = k.to_s
+          write_attribute(key, v) if types.key?(key)
+        end
+      end
+
+      def load_row(row)
+        self.class.columns.each { |col| @attributes[col] = Model.cast(self.class.type_of(col), row[col]) }
+        @raw = {}
+        @persisted = true
+      end
+
+      def write_attribute(col, v)
+        @raw[col] = v
+        @attributes[col] = Model.cast(self.class.type_of(col), v)
+      end
+
+      def as_json
+        h = {}
+        self.class.columns.each { |col| h[col] = @attributes[col] }
+        h
+      end
+    end
+  end
+end

data/lib/edgeway/model/macros.rb

@@ -0,0 +1,60 @@
+module Edgeway
+  module Model
+    module Macros
+      def attribute(name, type, default: nil)
+        attribute_types[name.to_s] = type
+        attribute_defaults[name.to_s] = default unless default.nil?
+        define_method(name) { @attributes[name.to_s] }
+        define_method("#{name}=") { |v| write_attribute(name.to_s, v) }
+      end
+
+      # created_at / updated_at, as ISO 8601 text: SQLite (so D1) has no datetime
+      # column type, the migrations declare them TEXT.
+      def timestamps
+        attribute :created_at, :datetime
+        attribute :updated_at, :datetime
+      end
+
+      # dependent: :destroy destroys the children (their own dependents run
+      # too), :delete_all deletes them with one DELETE. foreign_key: is the
+      # children's column and primary_key: ours (a String foreign key is
+      # declared with attribute on the child, as for belongs_to). An unset
+      # foreign_key stays nil: association works out "<model>_id" per call.
+      def has_many(name, dependent: nil, foreign_key: nil, primary_key: nil)
+        mode = nil
+        unless dependent.nil?
+          mode = dependent.to_s
+          raise ArgumentError, "unknown dependent: #{dependent}" unless mode == "destroy" || mode == "delete_all"
+        end
+        fk = foreign_key.nil? ? nil : foreign_key.to_s
+        pk = primary_key.nil? ? nil : primary_key.to_s
+        has_manys << Edgeway::Model::HasMany.new(name.to_s, fk, pk, mode)
+        define_method(name) do
+          association(name.to_s)
+        end
+      end
+
+      # foreign_key: is our column ("<name>_id" by default), primary_key: the
+      # parent's ("id"). A foreign key that is already declared keeps its type,
+      # which is how a String one is made: attribute :owner_uid, :string first.
+      # attribute is called either way (Spinel needs a macro call to be
+      # unconditional, and a macro body can't read attribute_types into a
+      # local), so keep_type/restore_type put the declared type back.
+      def belongs_to(name, foreign_key: nil, primary_key: nil)
+        fk = foreign_key.nil? ? "#{name}_id" : foreign_key.to_s
+        pk = primary_key.nil? ? "id" : primary_key.to_s
+        keep_type(fk)
+        if foreign_key.nil?
+          attribute "#{name}_id", :integer
+        else
+          attribute foreign_key, :integer
+        end
+        restore_type(fk)
+        belongs_to_list << Edgeway::Model::BelongsTo.new(name.to_s, fk, pk)
+        define_method(name) do
+          parent_of(name.to_s)
+        end
+      end
+    end
+  end
+end