edgeway 0.1.0 → 0.3.0

data/js/fetch.js

@@ -0,0 +1,113 @@
+import { jspiHelpers } from "./jspi.js";
+
+const LOCAL_HOSTS = ["localhost", "127.0.0.1", "[::1]"];
+export const DEFAULT_MAX_BYTES = 1024 * 1024;
+const BASE64_CHUNK = 8192;
+
+export function urlAllowed(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return false;
+  }
+  if (parsed.protocol === "https:") return true;
+  return parsed.protocol === "http:" && LOCAL_HOSTS.includes(parsed.hostname);
+}
+
+export function fetchWithTimeout(url, init, timeoutMs, fetch = globalThis.fetch) {
+  return fetch(url, { ...init, redirect: "manual", signal: AbortSignal.timeout(timeoutMs) });
+}
+
+function checkDeclaredSize(response, maxBytes) {
+  const declared = response.headers?.get("content-length");
+  if (declared !== null && declared !== undefined && Number(declared) > maxBytes) throw new Error("response is too large");
+}
+
+function joinChunks(chunks, size) {
+  const all = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    all.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return all;
+}
+
+// A chunked body has no Content-Length, so the size is counted again while reading.
+export async function readCapped(response, maxBytes) {
+  checkDeclaredSize(response, maxBytes);
+  if (!response.body) return new Uint8Array(0);
+  const reader = response.body.getReader();
+  const chunks = [];
+  let size = 0;
+  for (;;) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    size += value.byteLength;
+    if (size > maxBytes) {
+      await reader.cancel().catch(() => {});
+      throw new Error("response is too large");
+    }
+    chunks.push(value);
+  }
+  return joinChunks(chunks, size);
+}
+
+function base64Of(bytes) {
+  let binary = "";
+  for (let offset = 0; offset < bytes.length; offset += BASE64_CHUNK) {
+    binary += String.fromCharCode(...bytes.subarray(offset, offset + BASE64_CHUNK));
+  }
+  return btoa(binary);
+}
+
+const INVALID_REQUEST = "request is not valid UTF-8";
+
+export function parseRequest(bytes) {
+  try {
+    return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+  } catch {
+    return null;
+  }
+}
+
+function failure(error) {
+  if (error?.name === "TimeoutError") return { error: "request timed out", timeout: true };
+  return { error: String(error?.message ?? error) };
+}
+
+export async function performRequest(spec, { fetch = globalThis.fetch, maxBytes = DEFAULT_MAX_BYTES } = {}) {
+  if (!urlAllowed(spec.url)) return { error: "url must be https (http only for localhost)" };
+  try {
+    const init = { method: spec.method, headers: spec.headers };
+    if (spec.body) init.body = spec.body;
+    const response = await fetchWithTimeout(spec.url, init, spec.timeout_ms, fetch);
+    const bytes = await readCapped(response, maxBytes);
+    return { status: response.status, headers: Object.fromEntries(response.headers), body_base64: base64Of(bytes) };
+  } catch (error) {
+    return failure(error);
+  }
+}
+
+// The wasm import module "edgeway_fetch" (lib/edgeway/service/fetch.rb):
+//   request(json) -> {"status": n, "headers": {"lower-case-name": "value"}, "body_base64": "..."}
+//                  | {"error": "message"}
+//                  | {"error": "message", "timeout": true}
+// json is {"method", "url", "headers", "body", "timeout_ms"}. A redirect is not
+// followed: its response (with the location header) is the answer. A call answers the
+// byte length of the result and take() copies it out; request is wrapped in
+// WebAssembly.Suspending.
+export function fetchImports(getInstance, { fetch = globalThis.fetch, maxBytes = DEFAULT_MAX_BYTES } = {}) {
+  const { readBytes, setResult, take } = jspiHelpers(getInstance);
+
+  return {
+    edgeway_fetch: {
+      request: new WebAssembly.Suspending(async (specPointer) => {
+        const spec = parseRequest(readBytes(specPointer));
+        return setResult(spec ? await performRequest(spec, { fetch, maxBytes }) : { error: INVALID_REQUEST });
+      }),
+      take,
+    },
+  };
+}

data/js/headers.js

@@ -0,0 +1,16 @@
+const listOf = (value) => (value ?? "").split(",").map((item) => item.trim()).filter(Boolean);
+
+export function withHeaders(list, ...names) {
+  const have = listOf(list);
+  for (const name of names) {
+    if (!have.some((existing) => existing.toLowerCase() === name.toLowerCase())) have.push(name);
+  }
+  return have.join(", ");
+}
+
+// A Vary of * already covers every header.
+export function addVary(headers, ...names) {
+  const have = listOf(headers.get("Vary"));
+  if (have.includes("*")) return;
+  headers.set("Vary", withHeaders(have.join(", "), ...names));
+}

data/js/jspi.js

@@ -0,0 +1,32 @@
+const textDecoder = new TextDecoder("utf-8", { fatal: true });
+const textEncoder = new TextEncoder();
+
+// What the wasm side of a JSPI import module needs: C strings read from its
+// memory, and a result handed over in two steps, since an import can't return
+// a string. A suspending import answers the byte length of its JSON result and
+// the wasm side then calls take(buffer) to copy it.
+export function jspiHelpers(getInstance) {
+  const memory = () => new Uint8Array(getInstance().exports.memory.buffer);
+  let pending = new Uint8Array(0);
+
+  const readBytes = (pointer) => {
+    const bytes = memory();
+    let end = pointer;
+    while (bytes[end]) end++;
+    return bytes.subarray(pointer, end);
+  };
+
+  const readCString = (pointer) => textDecoder.decode(readBytes(pointer));
+
+  const setResult = (result) => {
+    pending = textEncoder.encode(JSON.stringify(result));
+    return pending.length;
+  };
+
+  const take = (buffer) => {
+    memory().set(pending, buffer);
+    pending = new Uint8Array(0);
+  };
+
+  return { readBytes, readCString, setResult, take };
+}

data/js/jwt.js

@@ -21,6 +21,8 @@
 // (RFC 7515 4.1.11: no extension is understood), and a JWKS key needs a `kid`
 // on the token and, if it has key_ops, "verify" in them.
 
+import { fetchWithTimeout, readCapped, urlAllowed } from "./fetch.js";
+
 const MAX_TOKEN = 8192;
 // A JWKS is kept this long, and re-fetched early (for an unknown kid) at
 // most this often.
@@ -90,45 +92,9 @@ function parseJsonPart(s, what) {
 // await I/O that another request started.
 const sharedCache = new Map();
 
-// Only https, so a JWKS can't be swapped on the way; a local server (tests,
-// `wrangler dev`) may use http.
-function jwksUrlAllowed(url) {
-  let u;
-  try {
-    u = new URL(url);
-  } catch {
-    return false;
-  }
-  if (u.protocol === "https:") return true;
-  return u.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(u.hostname);
-}
-
-// The body of res as text, at most MAX_JWKS bytes (checked on Content-Length
-// when there is one, and again while reading, because a chunked body has none).
 async function limitedText(res) {
-  const declared = res.headers?.get("content-length");
-  if (declared !== null && declared !== undefined && Number(declared) > MAX_JWKS) throw new Error("response is too large");
   if (!res.body) throw new Error("no body");
-  const reader = res.body.getReader();
-  const chunks = [];
-  let size = 0;
-  for (;;) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    size += value.byteLength;
-    if (size > MAX_JWKS) {
-      await reader.cancel().catch(() => {});
-      throw new Error("response is too large");
-    }
-    chunks.push(value);
-  }
-  const all = new Uint8Array(size);
-  let at = 0;
-  for (const c of chunks) {
-    all.set(c, at);
-    at += c.byteLength;
-  }
-  return new TextDecoder("utf-8", { fatal: true }).decode(all);
+  return new TextDecoder("utf-8", { fatal: true }).decode(await readCapped(res, MAX_JWKS));
 }
 
 export function jwtVerifier(env, { fetch = globalThis.fetch, now = Date.now, cache = sharedCache, timeoutMs = JWKS_TIMEOUT_MS } = {}) {
@@ -141,7 +107,7 @@ export function jwtVerifier(env, { fetch = globalThis.fetch, now = Date.now, cac
     // No stale JWKS: past its TTL (or when a forced refetch fails) a failed
     // fetch is "unavailable", never an old key.
     try {
-      const res = await fetch(url, { redirect: "manual", signal: AbortSignal.timeout(timeoutMs) });
+      const res = await fetchWithTimeout(url, {}, timeoutMs, fetch);
       if (res.status !== 200) throw new Error(`status ${res.status}`);
       const keys = JSON.parse(await limitedText(res)).keys;
       if (!Array.isArray(keys)) throw new Error("no keys");
@@ -189,7 +155,7 @@ export function jwtVerifier(env, { fetch = globalThis.fetch, now = Date.now, cac
     }
     const url = env.JWT_JWKS_URL;
     if (!url) throw new JwtError("JWT_JWKS_URL is not set", true);
-    if (!jwksUrlAllowed(url)) throw new JwtError("JWT_JWKS_URL must be https (http only for localhost)", true);
+    if (!urlAllowed(url)) throw new JwtError("JWT_JWKS_URL must be https (http only for localhost)", true);
     if (kid === undefined) throw new JwtError("kid is required");
     let entry = await loadKeys(url, false);
     let jwk = pick(entry, alg, algo, kid);
@@ -245,7 +211,7 @@ export function jwtVerifier(env, { fetch = globalThis.fetch, now = Date.now, cac
 //   verify(token) -> {"header": {...}, "payload": {...}}
 //                  | {"error": "message"}                      the token is bad
 //                  | {"error": "message", "unavailable": true}  it can't be checked
-// Like D1, a call answers the byte length of the result and take() copies it
+// Like the other imports, a call answers the byte length of the result and take() copies it
 // out; verify is wrapped in WebAssembly.Suspending (the WebCrypto and fetch
 // Promises are awaited with the wasm stack suspended).
 export function jwtImports(env, getInstance, options = {}) {

data/js/runtime.js

@@ -44,6 +44,41 @@ async function readBody(request) {
   return concatBytes(chunks);
 }
 
+const LOG_LEVELS = ["debug", "info", "warn", "error"];
+
+export function parseLogLine(line) {
+  if (!line.startsWith("{")) return null;
+  let entry;
+  try {
+    entry = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  const isObject = entry !== null && typeof entry === "object" && !Array.isArray(entry);
+  return isObject && LOG_LEVELS.includes(entry.level) && typeof entry.message === "string" ? entry : null;
+}
+
+export function logLine(line, logFields = {}, sink = console) {
+  const entry = parseLogLine(line);
+  if (entry) sink[entry.level]({ ...logFields, ...entry });
+  else sink.error(line);
+}
+
+export function lineSplitter(onLine) {
+  let pending = "";
+  return {
+    push(text) {
+      const lines = (pending + text).split(/\r?\n/);
+      pending = lines.pop();
+      for (const line of lines) if (line !== "") onLine(line);
+    },
+    flush() {
+      if (pending !== "") onLine(pending);
+      pending = "";
+    },
+  };
+}
+
 function internalError() {
   return new Response('{"error":"internal error"}\n', {
     status: 500,
@@ -55,23 +90,24 @@ function internalError() {
 // Response.
 //   extraEnv: more CGI environment variables (strings), such as the app's
 //             settings and EDGEWAY_ENV.
+//   logFields: fields added to every structured log line the app writes.
 //   imports:  (getInstance) => { moduleName: { name: fn } }, the wasm import
 //             modules besides WASI. A function wrapped in
 //             WebAssembly.Suspending may await (JSPI).
-export async function runCgi(appModule, request, { extraEnv = {}, imports = () => ({}) } = {}) {
+export async function runCgi(appModule, request, { extraEnv = {}, imports = () => ({}), logFields = {} } = {}) {
   const body = request.method === "GET" || request.method === "HEAD"
     ? new Uint8Array(0)
     : await readBody(request);
   if (body === null) return payloadTooLarge();
 
   const out = [];
-  let err = "";
+  const stderr = lineSplitter((line) => logLine(line, logFields));
   const wasi = new WASI({
     args: ["app"],
     env: { ...extraEnv, ...cgiEnv(request, body), SPINEL_GC_SLAB_MB: SLAB_MB },
     stdin: body,
     onStdoutBytes: (b) => out.push(b),
-    onStderr: (s) => (err += s),
+    onStderr: (text) => stderr.push(text),
   });
   // Whatever goes wrong inside the app (a trap, a non-zero exit) is logged
   // and answered with a fixed body: stderr and error messages never reach
@@ -86,10 +122,11 @@ export async function runCgi(appModule, request, { extraEnv = {}, imports = () =
     });
     status = await wasi.startAsync(instance);
   } catch (e) {
-    console.error("app trapped:", e, err);
+    stderr.flush();
+    console.error("app trapped:", e);
     return internalError();
   }
-  if (err) console.error(err);
+  stderr.flush();
   if (status !== 0) {
     console.error(`app exited with ${status}`);
     return internalError();

data/lib/edgeway/application.rb

@@ -29,28 +29,42 @@ module Edgeway
       elsif e.is_a?(InvalidToken)
         # The reason (e.message) goes to the log only; the client gets a fixed
         # body and challenge, so a probe learns nothing from the wording.
-        Edgeway.logger.info "401 #{e.message}"
+        Edgeway.logger.info(e.message, status: 401)
         unauthorized("invalid token", 'Bearer error="invalid_token"')
       elsif e.is_a?(Unauthorized)
-        Edgeway.logger.info "401 #{e.message}"
+        Edgeway.logger.info(e.message, status: 401)
         unauthorized("authentication required", "Bearer")
+      elsif e.is_a?(TooManyRequests)
+        too_many_requests(e)
       elsif e.is_a?(RecordNotUnique)
         # The message names the table and columns: the log only.
-        Edgeway.logger.info "409 #{e.message}"
+        Edgeway.logger.info(e.message, status: 409)
         message(409, "record not unique")
+      elsif e.is_a?(DatabaseUnavailable)
+        Edgeway.logger.error(e.message, status: 503)
+        response = message(503, "database unavailable")
+        response.headers["Retry-After"] = "1"
+        response
       elsif e.is_a?(RoutingError) || e.is_a?(RecordNotFound)
         # The message can hold the path or an id from the request: the log only.
-        Edgeway.logger.info "404 #{e.message}"
+        Edgeway.logger.info(e.message, status: 404)
         message(404, "not found")
       else
-        # The details go to the log (stderr), never to the client.
-        Edgeway.logger.error "#{e.class}: #{e.message}"
+        # The details go to the log, never to the client.
+        Edgeway.logger.error("#{e.class}: #{e.message}", status: 500)
         message(500, "internal error")
       end
     end
 
     private
 
+    def too_many_requests(error)
+      Edgeway.logger.info(error.message, status: 429)
+      response = message(429, "rate limit exceeded")
+      response.headers["Retry-After"] = error.retry_after.to_s if error.retry_after > 0
+      response
+    end
+
     def unauthorized(text, challenge)
       response = message(401, text)
       response.headers["WWW-Authenticate"] = challenge
@@ -58,9 +72,7 @@ module Edgeway
     end
 
     def message(status, text)
-      # .dup: since matz/spinel 44119ab30 (Strings shared by reference),
-      # Spinel refuses this String as it is, or emits C that doesn't compile.
-      Controller::Rendering.json_response(status, JSON.generate({ "error" => text.dup }))
+      Controller::Rendering.json_response(status, JSON.generate({ "error" => text }))
     end
   end
 

data/lib/edgeway/cache/limits.rb

@@ -0,0 +1,8 @@
+module Edgeway
+  module Cache
+    # A year. In wasm, Integers are 32 bits: epoch seconds plus an expires_in
+    # stop fitting in 2038, so a longer expiry is refused rather than allowed
+    # to overflow.
+    MAX_EXPIRES_IN = 31_536_000
+  end
+end

data/lib/edgeway/cache/memory_store.rb

@@ -0,0 +1,24 @@
+require_relative "store"
+
+module Edgeway
+  module Cache
+    class MemoryStore < Store
+      def initialize(namespace: nil, expires_in: nil)
+        super(namespace: namespace, expires_in: expires_in)
+        @texts = {}
+      end
+
+      def read_text(key) = @texts[key]
+
+      def write_text(key, text, expires_in_seconds)
+        @texts[key] = text
+        true
+      end
+
+      def delete_text(key)
+        @texts.delete(key)
+        true
+      end
+    end
+  end
+end

data/lib/edgeway/cache/null_store.rb

@@ -0,0 +1,13 @@
+require_relative "store"
+
+module Edgeway
+  module Cache
+    class NullStore < Store
+      def read_text(key) = nil
+
+      def write_text(key, text, expires_in_seconds) = true
+
+      def delete_text(key) = true
+    end
+  end
+end

data/lib/edgeway/cache/store.rb

@@ -0,0 +1,189 @@
+require_relative "limits"
+
+module Edgeway
+  module Cache
+    MAX_KEY_BYTES = 512
+    KEY_DIGEST_LENGTH = 64
+
+    def self.utf8?(text) = text.dup.force_encoding("UTF-8").valid_encoding?
+
+    class Store
+      def initialize(namespace: nil, expires_in: nil)
+        @namespace = namespace.nil? ? "" : namespace.dup.force_encoding("UTF-8")
+        @default_expires_in = expires_in.nil? ? 0 : checked_expires_in(expires_in)
+      end
+
+      def read(key)
+        entry = lookup(key)
+        entry.nil? ? nil : entry["v"]
+      end
+
+      def exist?(key) = !lookup(key).nil?
+
+      def write(key, value, expires_in: nil)
+        seconds = expires_in_seconds(expires_in)
+        check_cacheable(value)
+        write_text(expand_key(key), envelope(value, seconds), seconds)
+      end
+
+      def fetch(key, expires_in: nil, force: false, skip_nil: false)
+        unless block_given?
+          raise ArgumentError, "missing block" if force
+
+          return read(key)
+        end
+
+        unless force
+          entry = lookup(key)
+          return entry["v"] unless entry.nil?
+        end
+        value = yield
+        write(key, value, expires_in: expires_in) unless skip_nil && value.nil?
+        value
+      end
+
+      def delete(key) = delete_text(expand_key(key))
+
+      def read_text(key)
+        raise Edgeway::Error, "#{self.class.name} does not read"
+      end
+
+      def write_text(key, text, expires_in_seconds)
+        raise Edgeway::Error, "#{self.class.name} does not write"
+      end
+
+      def delete_text(key)
+        raise Edgeway::Error, "#{self.class.name} does not delete"
+      end
+
+      private
+
+      def current_time = Time.now.to_i
+
+      def lookup(key)
+        text = read_text(expand_key(key))
+        return nil if text.nil?
+
+        entry = parse_entry(text)
+        return nil if entry.nil? || expired?(entry)
+
+        entry
+      end
+
+      def parse_entry(text)
+        entry = JSON.parse(text)
+        entry.is_a?(Hash) && entry.key?("v") ? entry : nil
+      rescue JSON::ParserError
+        nil
+      end
+
+      def expired?(entry)
+        entry["e"].is_a?(Integer) && Integer(entry["e"]) <= current_time
+      end
+
+      def envelope(value, seconds)
+        entry = { "v" => value }
+        entry["e"] = current_time + seconds if seconds > 0
+        JSON.generate(entry)
+      end
+
+      def expires_in_seconds(expires_in)
+        expires_in.nil? ? @default_expires_in : checked_expires_in(expires_in)
+      end
+
+      def checked_expires_in(seconds)
+        unless seconds.is_a?(Integer) && Integer(seconds) > 0 && Integer(seconds) <= MAX_EXPIRES_IN
+          raise ArgumentError, "expires_in must be a whole number of seconds, 1 to #{MAX_EXPIRES_IN}"
+        end
+
+        seconds
+      end
+
+      def check_cacheable(value)
+        if value.is_a?(String)
+          check_text(value)
+        elsif value.is_a?(Array)
+          value.each { |item| check_cacheable(item) }
+        elsif value.is_a?(Hash)
+          check_hash(value)
+        elsif value.is_a?(Float)
+          raise ArgumentError, "a Float to cache must be finite" unless Float(value).finite?
+        elsif !json_scalar?(value)
+          raise ArgumentError, "#{value.class.name} can't be cached (String, Integer, Float, true, false, nil, Array and Hash can)"
+        end
+      end
+
+      def check_text(text)
+        raise ArgumentError, "a String to cache must be valid UTF-8 (a binary String is not)" unless Cache.utf8?(text)
+      end
+
+      def check_hash(hash)
+        names = {}
+        hash.each do |name, item|
+          unless name.is_a?(String) || name.is_a?(Symbol)
+            raise ArgumentError, "a Hash to cache needs String or Symbol keys (got #{name.class.name})"
+          end
+          raise ArgumentError, "a Hash to cache has the same key twice (as a String and a Symbol)" if names.key?(name.to_s)
+
+          names[name.to_s] = true
+          check_cacheable(name.to_s)
+          check_cacheable(item)
+        end
+      end
+
+      def json_scalar?(value) = value.nil? || value == true || value == false || value.is_a?(Integer)
+
+      def expand_key(key)
+        text = key_text(key)
+        raise ArgumentError, "cache key can't be blank" if text.empty?
+
+        text = "#{@namespace}:#{text}" unless @namespace.empty?
+        check_key_text(text)
+        text.bytesize > MAX_KEY_BYTES ? shortened(text) : text
+      end
+
+      def check_key_text(text)
+        raise ArgumentError, "cache key must be valid UTF-8" unless Cache.utf8?(text)
+        raise ArgumentError, "cache key can't contain a NUL byte" if text.include?("\0")
+      end
+
+      def key_text(key)
+        if key.is_a?(Edgeway::Model::Base)
+          model_key(key)
+        elsif key.is_a?(Array)
+          key.map { |part| key_text(part) }.join("/")
+        elsif key.is_a?(String)
+          utf8_key_part(key)
+        elsif key.is_a?(Symbol) || key.is_a?(Integer)
+          key.to_s
+        else
+          raise ArgumentError, "a cache key is a String, Symbol, Integer, model or an Array of them (got #{key.class.name})"
+        end
+      end
+
+      def utf8_key_part(part)
+        raise ArgumentError, "cache key must be valid UTF-8" unless Cache.utf8?(part)
+
+        part.dup.force_encoding("UTF-8")
+      end
+
+      def model_key(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.table_name}/#{model.id}-#{updated_at}"
+      end
+
+      def shortened(text)
+        prefix_bytes = MAX_KEY_BYTES - KEY_DIGEST_LENGTH - 1
+        prefix = +""
+        text.each_char do |character|
+          break if prefix.bytesize + character.bytesize > prefix_bytes
+
+          prefix << character
+        end
+        "#{prefix}:#{Digest::SHA256.hexdigest(text)}"
+      end
+    end
+  end
+end

data/lib/edgeway/cache.rb

@@ -0,0 +1,13 @@
+require_relative "cache/store"
+require_relative "cache/null_store"
+require_relative "cache/memory_store"
+
+module Edgeway
+  @cache = Cache::NullStore.new
+
+  def self.cache = @cache
+
+  def self.cache=(store)
+    @cache = store
+  end
+end

data/lib/edgeway/cli/build/app_config.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "database_config"
+
+module Edgeway
+  module CLI
+    class Build
+      class AppConfig
+        # adapter: => the file build/main.rb requires for it.
+        ADAPTERS = {
+          "d1" => "edgeway/service/cloudflare/d1",
+          "memory" => "edgeway/db/memory"
+        }.freeze
+
+        attr_reader :env, :adapter, :binding_name, :databases, :sessions
+
+        def self.load(root, env)
+          config = DatabaseConfig.new(root)
+          section = config.section(env)
+          databases = config.databases_in(section, env)
+          sessions = config.session_bindings(section, env)
+          new(env, section["adapter"].to_s, config.primary_binding(section), databases, sessions)
+        end
+
+        def initialize(env, adapter, binding_name, databases = {}, sessions = [])
+          raise Error, "unknown database adapter #{adapter.inspect} (one of #{ADAPTERS.keys.join(", ")})" unless ADAPTERS.key?(adapter)
+
+          @env = env
+          @adapter = adapter
+          @binding_name = binding_name
+          @databases = databases
+          @sessions = adapter == "d1" ? sessions : []
+        end
+
+        def adapter_file = ADAPTERS.fetch(@adapter)
+      end
+    end
+  end
+end