edgeway 0.2.0 → 0.3.0

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

@@ -9,6 +9,7 @@ require_relative "cli/toolchain"
 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"
@@ -24,6 +25,7 @@ module Edgeway
                                  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
+                                   (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

data/lib/edgeway/controller/base.rb

@@ -5,16 +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?",
-                     "action_name", "action_name=", "raw"]
+                     "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 || [])
 
@@ -67,7 +86,7 @@ module Edgeway
 
       def action?(name)
         return false if name.start_with?("_view_") || name.start_with?("_render_")
-        respond_to?(name.to_sym) && !NON_ACTIONS.include?(name)
+        respond_to?(name.to_sym) && !NON_ACTIONS.include?(name) && !self.class.non_action?(name)
       end
 
       def raw(text) = View::SafeHTML.new(text)

data/lib/edgeway/controller/caching.rb

@@ -0,0 +1,140 @@
+module Edgeway
+  module Controller
+    # HTTP caching helpers for actions:
+    #
+    #   def show
+    #     todo = Todo.find(params["id"])
+    #     render json: todo if stale?(etag: todo, last_modified: todo.updated_at)
+    #   end
+    #
+    # Only the validators an action names are used; nothing is derived from
+    # the response body.
+    module Caching
+      ETAG_LENGTH = 32
+
+      def expires_in(seconds, public: false, must_revalidate: false)
+        raise ArgumentError, "seconds must be a non-negative Integer" unless Caching.duration?(seconds)
+        value = "max-age=#{seconds}, #{public ? "public" : "private"}"
+        value += ", must-revalidate" if must_revalidate
+        @headers["Cache-Control"] = value
+        nil
+      end
+
+      def no_store
+        @headers["Cache-Control"] = "no-store"
+        nil
+      end
+
+      # Returns true when it answered 304 (the action is done), false
+      # otherwise.
+      def fresh_when(etag: nil, last_modified: nil, public: false)
+        etag_value = etag.nil? ? nil : Caching.etag_for(etag)
+        modified_time = Caching.time_for(last_modified)
+        @headers["ETag"] = etag_value unless etag_value.nil?
+        @headers["Last-Modified"] = modified_time.httpdate unless modified_time.nil?
+        set_default_cache_control(public)
+        return false unless cacheable_request? && request_fresh?(etag_value, modified_time)
+        remove_representation_headers
+        head :not_modified
+        true
+      end
+
+      # fresh_when, answering true when the action should go on to render.
+      def stale?(etag: nil, last_modified: nil, public: false)
+        !fresh_when(etag: etag, last_modified: last_modified, public: public)
+      end
+
+      # Integer() gives Spinel a type for a parameter no call site types.
+      def self.duration?(seconds)
+        seconds.is_a?(Integer) && Integer(seconds) >= 0
+      end
+
+      # Weak, because a proxy may recompress the body and weaken a strong
+      # validator on the way.
+      def self.etag_for(source)
+        digest = Digest::SHA256.hexdigest(etag_source(source))
+        "W/\"#{digest[0, ETAG_LENGTH]}\""
+      end
+
+      def self.etag_source(source)
+        if source.is_a?(Model::Base)
+          model_source(source)
+        elsif source.is_a?(Model::Relation)
+          list_source(source.to_a)
+        elsif source.is_a?(Array)
+          list_source(source)
+        else
+          source.to_s
+        end
+      end
+
+      def self.model_source(model)
+        updated_at = model.as_json["updated_at"].to_s
+        raise ArgumentError, "#{model.class.name} has no updated_at (add timestamps)" if updated_at.empty?
+        "#{model.class.name}/#{model.id}/#{updated_at}"
+      end
+
+      def self.list_source(items)
+        "[" + items.map { |item| etag_source(item) }.join(",") + "]"
+      end
+
+      def self.time_for(value)
+        return nil if value.nil?
+        return value.getutc if value.is_a?(Time)
+        raise ArgumentError, "last_modified must be a Time or an ISO 8601 String" unless value.is_a?(String)
+        begin
+          Time.iso8601(value).utc
+        rescue ArgumentError
+          raise ArgumentError, "last_modified is not an ISO 8601 String: #{value.inspect}"
+        end
+      end
+
+      # The validators match the ones the client sent (RFC 9110 13.1.2,
+      # 13.1.3): If-None-Match decides when it is present, and
+      # If-Modified-Since is then ignored.
+      def self.fresh?(none_match, modified_since, etag, last_modified)
+        return etag_listed?(none_match, etag) unless none_match.empty?
+        return false if modified_since.empty? || last_modified.nil?
+        since = parse_http_date(modified_since)
+        !since.nil? && last_modified.to_i <= since.to_i
+      end
+
+      def self.etag_listed?(header, etag)
+        return false if etag.nil?
+        candidates = header.split(",").map { |candidate| candidate.strip }
+        return true if candidates.include?("*")
+        candidates.any? { |candidate| candidate.delete_prefix("W/") == etag.delete_prefix("W/") }
+      end
+
+      def self.parse_http_date(text)
+        Time.httpdate(text).utc
+      rescue ArgumentError
+        nil
+      end
+
+      private
+
+      def set_default_cache_control(public)
+        return if header_set?("Cache-Control")
+        @headers["Cache-Control"] = "max-age=0, #{public ? "public" : "private"}, must-revalidate"
+      end
+
+      def header_set?(name)
+        @headers.keys.any? { |key| key.downcase == name.downcase }
+      end
+
+      def remove_representation_headers
+        @headers.delete("Content-Type")
+        @headers.delete("X-Content-Type-Options")
+      end
+
+      def cacheable_request?
+        @request.method == "GET" || @request.method == "HEAD"
+      end
+
+      def request_fresh?(etag_value, modified_time)
+        Caching.fresh?(@request.header("If-None-Match"), @request.header("If-Modified-Since"), etag_value, modified_time)
+      end
+    end
+  end
+end

data/lib/edgeway/controller/callbacks.rb

@@ -9,6 +9,10 @@ module Edgeway
         @except = except
       end
 
+      def run(controller)
+        controller.send(@name)
+      end
+
       def applies?(action)
         return false if @except.include?(action)
         @only.empty? || @only.include?(action)
@@ -19,7 +23,7 @@ module Edgeway
       def run_before_actions(action)
         self.class.all_before_actions.each do |callback|
           next unless callback.applies?(action)
-          send(callback.name)
+          callback.run(self)
           return false if performed?
         end
         true

data/lib/edgeway/controller/rate_limiting.rb

@@ -0,0 +1,145 @@
+module Edgeway
+  module Controller
+    @rate_limiter = RateLimit::NullLimiter.new
+
+    def self.rate_limiter = @rate_limiter
+
+    def self.rate_limiter=(limiter)
+      @rate_limiter = limiter
+    end
+
+    # Rate limiting through a limiter binding:
+    #
+    #   class PostsController < ApplicationController
+    #     rate_limit "WRITE_LIMITER", only: [:create], retry_after: 10
+    #   end
+    #
+    # It is a before_action. Over the limit it raises TooManyRequests (429).
+    # The limit and the period are set on the binding, not here. A by: method is
+    # never a route's action (Base.rate_limit adds it to the non-actions).
+    module RateLimiting
+      class Rule < Callback
+        attr_reader :binding_name, :by, :scope_name, :retry_after
+
+        def self.build(binding_name, by, name, retry_after, only, except)
+          raise ArgumentError, "the limiter binding name must be a non-empty String" unless binding_name.is_a?(String) && !binding_name.empty?
+          raise ArgumentError, "by: must be a Symbol" unless by.nil? || by.is_a?(Symbol)
+          raise ArgumentError, "name: must be a String" unless name.nil? || name.is_a?(String)
+          raise ArgumentError, "retry_after: must be a positive Integer" unless retry_after.nil? || RateLimiting.positive_integer?(retry_after)
+          new(binding_name, by, name, retry_after.nil? ? 0 : retry_after, only.map(&:to_s), except.map(&:to_s))
+        end
+
+        def initialize(binding_name, by, name, retry_after, only, except)
+          super("rate_limit", only, except)
+          @binding_name = binding_name
+          @by = by
+          @scope_name = name
+          @retry_after = retry_after
+        end
+
+        def run(controller)
+          controller.send(:enforce_rate_limit, self)
+        end
+      end
+
+      IPV6_GROUPS = 8
+      IPV6_PREFIX_GROUPS = 4
+      IPV4_OCTETS = 4
+      IPV4_MAPPED_ZERO_GROUPS = 5
+      IPV4_MAPPED_MARKER_GROUP = 5
+      IPV4_HIGH_GROUP = 6
+      IPV4_LOW_GROUP = 7
+      HEX_DIGITS = "0123456789abcdef"
+
+      # An IPv6 client usually has a whole /64, so its address is keyed by
+      # that prefix; an IPv4 address (or one that does not parse) is kept.
+      def self.address_key(address)
+        return address unless address.include?(":")
+
+        text = address.downcase.split("%")[0].to_s
+        groups = ipv6_groups(embedded_ipv4_as_hex(text))
+        return address if groups.nil?
+
+        ipv4_mapped?(groups) ? ipv4_from_groups(groups) : groups[0, IPV6_PREFIX_GROUPS].join(":") + "::/64"
+      end
+
+      # "::ffff:192.0.2.1" -> "::ffff:c000:201", so the dotted tail parses as two groups.
+      def self.embedded_ipv4_as_hex(text)
+        colon = text.rindex(":").to_i
+        octets = text[colon + 1, text.length].to_s.split(".", -1)
+        return text unless octets.length == IPV4_OCTETS && octets.all? { |octet| decimal_octet?(octet) }
+
+        values = octets.map { |octet| octet.to_i }
+        high = (values[0] * 256 + values[1]).to_s(16)
+        low = (values[2] * 256 + values[3]).to_s(16)
+        text[0, colon + 1].to_s + high + ":" + low
+      end
+
+      def self.decimal_octet?(octet)
+        octet.length >= 1 && octet.length <= 3 && octet.each_char.all? { |digit| "0123456789".include?(digit) } && octet.to_i <= 255
+      end
+
+      def self.ipv4_mapped?(groups)
+        groups[0, IPV4_MAPPED_ZERO_GROUPS].all? { |group| group == "0" } && groups[IPV4_MAPPED_MARKER_GROUP] == "ffff"
+      end
+
+      def self.ipv4_from_groups(groups)
+        high = groups[IPV4_HIGH_GROUP].to_i(16)
+        low = groups[IPV4_LOW_GROUP].to_i(16)
+        [high / 256, high % 256, low / 256, low % 256].join(".")
+      end
+
+      def self.ipv6_groups(text)
+        halves = text.split("::", -1)
+        return nil if halves.empty? || halves.length > 2
+
+        head = group_list(halves[0])
+        tail = halves.length == 2 ? group_list(halves[1]) : []
+        return nil if head.nil? || tail.nil?
+
+        filler = IPV6_GROUPS - head.length - tail.length
+        return nil if halves.length == 1 ? filler != 0 : filler < 1
+
+        head + Array.new(filler, "0") + tail
+      end
+
+      def self.group_list(text)
+        return [] if text.empty?
+
+        groups = text.split(":", -1).map { |group| normalized_group(group) }
+        groups.include?("") ? nil : groups
+      end
+
+      def self.normalized_group(group)
+        return "" if group.empty? || group.length > 4 || !group.each_char.all? { |digit| HEX_DIGITS.include?(digit) }
+
+        group.to_i(16).to_s(16)
+      end
+
+      # Integer() gives Spinel a type for a parameter no call site types.
+      def self.positive_integer?(value)
+        value.is_a?(Integer) && Integer(value) > 0
+      end
+
+      private
+
+      def enforce_rate_limit(rule)
+        return unless Edgeway::Controller.rate_limiter.exceeded?(rule.binding_name, rate_limit_key_for(rule))
+
+        raise TooManyRequests.new("rate limit exceeded (#{rule.binding_name})", rule.retry_after)
+      end
+
+      def rate_limit_key_for(rule)
+        scope = rule.scope_name.nil? ? self.class.name : rule.scope_name
+        "#{scope}:#{rule.by.nil? ? default_rate_limit_key : send(rule.by).to_s}"
+      end
+
+      def default_rate_limit_key
+        subject = authenticated? ? current_claims["sub"].to_s : ""
+        return "user:#{subject}" unless subject.empty?
+
+        "ip:#{RateLimiting.address_key(request.remote_addr)}"
+      end
+    end
+  end
+end

data/lib/edgeway/db/query_stats.rb

@@ -27,16 +27,12 @@ module Edgeway
         @queries = capped_sum(@queries, 1)
       end
 
-      def log_text
-        "db=#{@queries} rows_read=#{count_text(@rows_read)} rows_written=#{count_text(@rows_written)} db_ms=#{format("%.2f", @duration_ms)}"
+      def log_fields
+        { "queries" => @queries, "rows_read" => @rows_read, "rows_written" => @rows_written, "db_ms" => @duration_ms.round(2) }
       end
 
       private
 
-      def count_text(count)
-        count == MAX_COUNT ? "#{count}+" : count.to_s
-      end
-
       def capped_sum(total, count)
         return MAX_COUNT if count.to_i > MAX_COUNT - total
         total + count.to_i

data/lib/edgeway/errors.rb

@@ -28,6 +28,17 @@ module Edgeway
   # ({"error":"invalid token"}) and the challenge no description.
   class InvalidToken < Unauthorized; end
 
+  # A request over a rate limit: 429 with a fixed body. retry_after is the
+  # seconds for a Retry-After header, 0 for none.
+  class TooManyRequests < Error
+    attr_reader :retry_after
+
+    def initialize(message = "rate limit exceeded", retry_after = 0)
+      super(message)
+      @retry_after = retry_after.is_a?(Integer) && Integer(retry_after) > 0 ? retry_after : 0
+    end
+  end
+
   # A record that doesn't exist: 404.
   class RecordNotFound < Error; end
 
@@ -71,6 +82,16 @@ module Edgeway
   # been applied, so only an idempotent request is safe to retry.
   class DatabaseUnavailable < DatabaseError; end
 
+  module HTTP
+    # An outgoing request that failed (a network error, a URL that is refused,
+    # a response over the size limit): 500. The message goes to the log only.
+    class Error < Edgeway::Error; end
+
+    # An outgoing request that did not finish within its timeout: 500. The
+    # message goes to the log only.
+    class Timeout < Error; end
+  end
+
   # A record that failed its validations: 422 with {"errors": [...]}.
   class RecordInvalid < Error
     attr_reader :errors

data/lib/edgeway/generators/app/templates/.github/workflows/ci.yml.tt

@@ -20,9 +20,6 @@ jobs:
       - uses: actions/checkout@d23441a48e516b6c34aea4fa41551a30e30af803 # v6.1.0
         with:
           persist-credentials: false
-      # `edgeway test` links libsqlite3.
-      - name: Install libsqlite3-dev
-        run: sudo apt-get update && sudo apt-get install -y libsqlite3-dev
       # The Ruby in .ruby-version.
       - name: Set up Ruby
         uses: ruby/setup-ruby@651ff0d62c5c79bed6d53ec518387aae20e72c1a # v1.329.0
@@ -32,6 +29,9 @@ jobs:
       # Node.js, and <%= PackageManager.name %>.
       - name: Install the tools
         uses: jdx/mise-action@9b200bcecbfd6303e69a4a261b2e09e3757440a7 # v5.2.0
+      # `edgeway test` runs the tests on the local D1 of wrangler.
+      - name: Install wrangler
+        run: <%= PackageManager.install %>
       - name: Run the tests
         run: bin/test
       - name: Build

data/lib/edgeway/generators/app/templates/README.md.tt

@@ -17,9 +17,11 @@ bundle exec edgeway routes
 
 `bin/deploy` builds with `--release`: one unit, without Spinel's `--incremental` (cached C units, no inlining across units), for deploying.
 
+Files in `public/` are served by Cloudflare before the app, for every method on their path (see Edgeway's README, "Static assets").
+
 Without mise, set `SPINEL` to the Spinel compiler and `WASI_SDK` to the WASI SDK.
 
-Tests (`test/`) run with `bin/test [FILE...]` (all of `test/` when no file is given; it runs `bundle exec edgeway test`). Always use it rather than `spinel_test-unit` directly: it rewrites `tmp/test_app.rb` (git-ignored) from `app/` on every run, so new files are picked up. Each test gets a fresh in-memory SQLite database with `db/migrations/*.sql` applied, so running the tests requires SQLite (sqlite3): its development library has to be installed to link (`apt install libsqlite3-dev` on Debian/Ubuntu, `dnf install sqlite-devel` on Fedora; macOS has it).
+Tests (`test/`) run with `bin/test [FILE...]` (all of `test/` when no file is given; it runs `bundle exec edgeway test`). Always use it rather than `spinel_test-unit` directly: it rewrites `tmp/test_app.rb` (git-ignored) from `app/` on every run, so new files are picked up. The tests are compiled to wasm like the app and run by node on wrangler's local D1 (in memory, so `.wrangler/state` is not touched); each test gets an emptied database with `db/migrations/*.sql` applied. This needs the tools of `bin/setup` (Spinel, the WASI SDK, Node.js and wrangler).
 
 `.github/workflows/ci.yml` runs `bin/test` and `bin/build --release` on GitHub Actions for pushes to main and pull requests.
 

data/lib/edgeway/generators/app/templates/bin/setup.tt

@@ -3,8 +3,7 @@
 set -euo pipefail
 cd "$(dirname "$0")/.."
 
-# Spinel and the WASI SDK, from mise.toml. `edgeway test` also links libsqlite3
-# (libsqlite3-dev on Debian/Ubuntu; part of macOS).
+# Spinel, the WASI SDK and Node.js, from mise.toml.
 if command -v mise >/dev/null 2>&1; then
   mise trust --quiet
   mise install
@@ -15,7 +14,7 @@ fi
 
 bundle install
 
-# wrangler, from package.json.
+# wrangler, from package.json (`edgeway test` runs the tests on its local D1).
 if ! command -v <%= PackageManager.name %> >/dev/null 2>&1; then
   echo "bin/setup: <%= PackageManager.name %> is not installed; install it to get wrangler." >&2
   exit 1

data/lib/edgeway/generators/app/templates/config/cache.yml

@@ -0,0 +1,22 @@
+# The cache store of each environment (edgeway build --env ENV), Edgeway.cache
+# (see the README's "Caching"). Without this file, or a section for the
+# environment, the store is null: it keeps nothing, so Edgeway.cache.fetch
+# always runs its block.
+#
+#   store:       kv, memory or null. kv keeps entries in a Cloudflare KV
+#                namespace; memory keeps them for the one request only.
+#   binding:     the name of a [[kv_namespaces]] binding in wrangler.toml (kv).
+#   namespace:   a prefix for every key (optional).
+#   expires_in:  the seconds an entry lives when the call gives none (optional).
+#
+# `edgeway test` always uses a null store, whatever this file says.
+#   production:
+#     store: kv
+#     binding: CACHE
+#     namespace: myapp
+#     expires_in: 3600
+development:
+  store: null
+
+production:
+  store: null

data/lib/edgeway/generators/app/templates/config/database.yml

@@ -1,7 +1,12 @@
 # The database of each environment (edgeway build --env ENV), compiled into
 # the wasm. adapter: d1 uses the D1 binding named by binding:, which must
 # match a binding in wrangler.toml (wrangler.toml says which D1 database it
-# is); memory is for tests.
+# is); memory is a database that stores nothing (as the test: adapter it
+# means native tests on SQLite instead; see the README's "Testing an app").
+#
+# `edgeway test` runs the tests on a local D1 (in memory, like `wrangler dev`)
+# with adapter: d1, each test starting from the migrations (db/migrations and
+# db/<name>/migrations).
 #
 # Another database goes under databases:, which a model picks with
 # `self.database = :analytics` (see the README's "Multiple databases").
@@ -28,4 +33,5 @@ production:
   binding: DB
 
 test:
-  adapter: memory
+  adapter: d1
+  binding: DB

data/lib/edgeway/generators/app/templates/public/.assetsignore

@@ -0,0 +1 @@
+# Files in public/ not to upload as static assets (.gitignore syntax).

data/lib/edgeway/generators/app/templates/wrangler.toml.tt

@@ -2,6 +2,11 @@ name = "<%= @name %>"
 main = "src/worker.js"
 compatibility_date = "2026-10-01"
 
+# Workers Logs records what the app logs (Edgeway.logger), one entry per line,
+# with its fields indexed (see the README's "Logging").
+[observability]
+enabled = true
+
 # CORS, for a frontend on another origin (see the README's "CORS"): the
 # origins allowed, comma-separated and compared exactly (no trailing slash).
 # Unset, CORS is off. CORS_HEADERS defaults to "Authorization, Content-Type",
@@ -11,6 +16,14 @@ compatibility_date = "2026-10-01"
 # [vars]
 # CORS_ORIGINS = "http://localhost:3000, https://app.example"
 
+# Files in public/ are served as is, without starting the app, so they are
+# always public: `before_action :authenticate!` never sees them. A file takes
+# its path from the app for every method (other than GET/HEAD it is 405):
+# public/index.html answers `/`, public/todos.html `/todos`. Anything else goes
+# to the app. For an SPA, see Edgeway's README, "Static assets".
+[assets]
+directory = "./public"
+
 # Simulated locally by `wrangler dev`. Create tables with
 # `<%= PackageManager.exec %> wrangler d1 migrations apply <%= @name %>-db --local`.
 # database_id is a placeholder (all zeros): that is enough for --local and
@@ -22,9 +35,28 @@ database_name = "<%= @name %>-db"
 database_id = "00000000-0000-0000-0000-000000000000"
 migrations_dir = "db/migrations"
 
-# A second database (config/database.yml's databases:) is another binding:
+# A second database (config/database.yml's databases:) is another binding,
+# with an id of its own: the same id is the same local database:
 # [[d1_databases]]
 # binding = "ANALYTICS"
 # database_name = "<%= @name %>-analytics"
-# database_id = "00000000-0000-0000-0000-000000000000"
+# database_id = "00000000-0000-0000-0000-000000000001"
 # migrations_dir = "db/analytics/migrations"
+
+# The cache (config/cache.yml, `store: kv`; see Edgeway's README, "Caching") keeps
+# its entries in a KV namespace. Simulated locally by `wrangler dev`. Before a
+# deploy, create the namespace (`<%= PackageManager.exec %> wrangler kv namespace create CACHE`)
+# and put the id it prints here.
+# [[kv_namespaces]]
+# binding = "CACHE"
+# id = "00000000000000000000000000000000"
+
+# Rate limiting (`rate_limit "API_LIMITER"` in a controller; see Edgeway's README,
+# "Rate limiting"). The period is 10 or 60 seconds; namespace_id is a positive
+# integer, as a string, that is unique in your account. `wrangler dev` enforces it.
+# [[ratelimits]]
+# name = "API_LIMITER"
+# namespace_id = "1001"
+#   [ratelimits.simple]
+#   limit = 100
+#   period = 60