@shaferllc/keel 0.36.0 → 0.59.0

package/dist/core/model.d.ts

@@ -15,7 +15,7 @@
  *   user.email = "new@x.com";
  *   await user.save();
  */
-import { type QueryBuilder, type Row } from "./database.js";
+import { type QueryBuilder, type Row, type Paginated } from "./database.js";
 import { BelongsTo, BelongsToMany, HasMany, HasOne } from "./relations.js";
 import { type Casts } from "./casts.js";
 type ModelClass<T extends Model> = (new (attributes?: Row) => T) & typeof Model;
@@ -28,6 +28,10 @@ export declare class Model {
     static guarded: string[];
     /** Column -> cast type; values round-trip as real JS types. */
     static casts: Casts;
+    /** Auto-manage `created_at` / `updated_at` on write. Off by default. */
+    static timestamps: boolean;
+    static createdAtColumn: string;
+    static updatedAtColumn: string;
     [key: string]: unknown;
     constructor(attributes?: Row);
     /** A raw query builder scoped to this model's table. */
@@ -36,6 +40,8 @@ export declare class Model {
     static filterFillable(attributes: Row): Row;
     /** Cast attributes to their storable primitives for a write. */
     static toDatabase(attributes: Row): Row;
+    /** Stamp created_at/updated_at onto a write payload when timestamps are on. */
+    static stampTimestamps(data: Row, forInsert: boolean): Row;
     static all<T extends Model>(this: ModelClass<T>): Promise<T[]>;
     static find<T extends Model>(this: ModelClass<T>, id: unknown): Promise<T | null>;
     static findOrFail<T extends Model>(this: ModelClass<T>, id: unknown): Promise<T>;
@@ -43,6 +49,14 @@ export declare class Model {
     /** Fetch models matching a simple equality condition. */
     static where<T extends Model>(this: ModelClass<T>, column: string, value: unknown): Promise<T[]>;
     static create<T extends Model>(this: ModelClass<T>, attributes: Row): Promise<T>;
+    /** A page of models plus pagination metadata. */
+    static paginate<T extends Model>(this: ModelClass<T>, page?: number, perPage?: number): Promise<Paginated<T>>;
+    /** Find the first row matching `match`, or create one from `{ ...match, ...values }`. */
+    static firstOrCreate<T extends Model>(this: ModelClass<T>, match: Row, values?: Row): Promise<T>;
+    /** Update the first row matching `match` with `values`, or create it. */
+    static updateOrCreate<T extends Model>(this: ModelClass<T>, match: Row, values?: Row): Promise<T>;
+    /** A query scoped to every column/value in `match`. */
+    private static matching;
     /**
      * Eager-load relations onto an array of models with one extra query each —
      * the fix for N+1. Each name must be a relationship method on the model.
@@ -65,6 +79,10 @@ export declare class Model {
     getRelation<T = unknown>(name: string): T | undefined;
     /** Insert (no primary key) or update (has one). */
     save(): Promise<this>;
+    /** Mass-assign then save — `fill` + `save` in one call. */
+    update(attributes: Row): Promise<this>;
+    /** Reload this model's columns from the database. */
+    refresh(): Promise<this>;
     delete(): Promise<void>;
     /** Merge mass-assignable attributes into the model (cast, not saved). */
     fill(attributes: Row): this;

package/dist/core/model.js

@@ -40,6 +40,10 @@ export class Model {
     static guarded = [];
     /** Column -> cast type; values round-trip as real JS types. */
     static casts = {};
+    /** Auto-manage `created_at` / `updated_at` on write. Off by default. */
+    static timestamps = false;
+    static createdAtColumn = "created_at";
+    static updatedAtColumn = "updated_at";
     constructor(attributes = {}) {
         // Hydration is unguarded (rows come from the database) but always cast.
         Object.assign(this, applyCasts(attributes, this.constructor.casts, castGet));
@@ -70,6 +74,17 @@ export class Model {
     static toDatabase(attributes) {
         return applyCasts(attributes, this.casts, castSet);
     }
+    /** Stamp created_at/updated_at onto a write payload when timestamps are on. */
+    static stampTimestamps(data, forInsert) {
+        if (!this.timestamps)
+            return data;
+        const now = new Date().toISOString();
+        const out = { ...data };
+        if (forInsert)
+            out[this.createdAtColumn] = now;
+        out[this.updatedAtColumn] = now;
+        return out;
+    }
     static async all() {
         const rows = await db(this.table).get();
         return rows.map((row) => new this(row));
@@ -95,12 +110,46 @@ export class Model {
     }
     static async create(attributes) {
         const filtered = this.filterFillable(attributes);
-        const id = await db(this.table).insertGetId(this.toDatabase(filtered));
+        const write = this.stampTimestamps(this.toDatabase(filtered), true);
+        const id = await db(this.table).insertGetId(write);
         const model = new this(filtered);
+        if (this.timestamps) {
+            model[this.createdAtColumn] = write[this.createdAtColumn];
+            model[this.updatedAtColumn] = write[this.updatedAtColumn];
+        }
         if (id != null)
             model[this.primaryKey] = id;
         return model;
     }
+    /** A page of models plus pagination metadata. */
+    static async paginate(page = 1, perPage = 15) {
+        const result = await db(this.table).paginate(page, perPage);
+        return { ...result, data: result.data.map((row) => new this(row)) };
+    }
+    /** Find the first row matching `match`, or create one from `{ ...match, ...values }`. */
+    static async firstOrCreate(match, values = {}) {
+        const row = await this.matching(match).first();
+        if (row)
+            return new this(row);
+        return this.create({ ...match, ...values });
+    }
+    /** Update the first row matching `match` with `values`, or create it. */
+    static async updateOrCreate(match, values = {}) {
+        const row = await this.matching(match).first();
+        if (row) {
+            const model = new this(row);
+            await model.forceFill(values).save();
+            return model;
+        }
+        return this.create({ ...match, ...values });
+    }
+    /** A query scoped to every column/value in `match`. */
+    static matching(match) {
+        let q = db(this.table);
+        for (const [column, value] of Object.entries(match))
+            q = q.where(column, value);
+        return q;
+    }
     /**
      * Eager-load relations onto an array of models with one extra query each —
      * the fix for N+1. Each name must be a relationship method on the model.
@@ -161,10 +210,17 @@ export class Model {
     async save() {
         const ctor = this.ctor();
         const { table, primaryKey } = ctor;
-        const data = ctor.toDatabase({ ...this });
-        const idValue = data[primaryKey];
+        const idValue = this[primaryKey];
+        const forInsert = idValue == null;
+        const data = ctor.stampTimestamps(ctor.toDatabase({ ...this }), forInsert);
+        // Reflect the stamps back onto the instance.
+        if (ctor.timestamps) {
+            if (forInsert)
+                this[ctor.createdAtColumn] = data[ctor.createdAtColumn];
+            this[ctor.updatedAtColumn] = data[ctor.updatedAtColumn];
+        }
         delete data[primaryKey];
-        if (idValue != null) {
+        if (!forInsert) {
             await db(table).where(primaryKey, idValue).update(data);
         }
         else {
@@ -174,6 +230,18 @@ export class Model {
         }
         return this;
     }
+    /** Mass-assign then save — `fill` + `save` in one call. */
+    async update(attributes) {
+        return this.fill(attributes).save();
+    }
+    /** Reload this model's columns from the database. */
+    async refresh() {
+        const ctor = this.ctor();
+        const row = await db(ctor.table).where(ctor.primaryKey, this[ctor.primaryKey]).first();
+        if (row)
+            Object.assign(this, applyCasts(row, ctor.casts, castGet));
+        return this;
+    }
     async delete() {
         const { table, primaryKey } = this.ctor();
         await db(table).where(primaryKey, this[primaryKey]).delete();

package/dist/core/provider.d.ts

@@ -1,16 +1,25 @@
 /**
- * Service providers are the central place to configure the application.
+ * Service providers are the central place to configure the application — Keel's
+ * plugin system. A provider packages a slice of functionality and wires it in.
  *
  * register(): bind things into the container. Do NOT resolve other services
  *             here — nothing is guaranteed to be registered yet.
  * boot():     called after every provider has registered. Safe to resolve
  *             and wire things together here.
+ *
+ * Register with options to make a provider reusable:
+ *
+ *   class RateLimitProvider extends ServiceProvider<{ max: number }> {
+ *     boot() { this.app.make(HttpKernel).use(rateLimiter({ max: this.options.max })); }
+ *   }
+ *   app.register(RateLimitProvider, { max: 100 });
  */
 import type { Application } from "./application.js";
-export declare abstract class ServiceProvider {
+export declare abstract class ServiceProvider<O = Record<string, unknown>> {
     protected app: Application;
-    constructor(app: Application);
+    protected options: O;
+    constructor(app: Application, options?: O);
     register(): void | Promise<void>;
     boot(): void | Promise<void>;
 }
-export type ProviderClass = new (app: Application) => ServiceProvider;
+export type ProviderClass = new (app: Application, options?: any) => ServiceProvider;

package/dist/core/provider.js

@@ -1,15 +1,25 @@
 /**
- * Service providers are the central place to configure the application.
+ * Service providers are the central place to configure the application — Keel's
+ * plugin system. A provider packages a slice of functionality and wires it in.
  *
  * register(): bind things into the container. Do NOT resolve other services
  *             here — nothing is guaranteed to be registered yet.
  * boot():     called after every provider has registered. Safe to resolve
  *             and wire things together here.
+ *
+ * Register with options to make a provider reusable:
+ *
+ *   class RateLimitProvider extends ServiceProvider<{ max: number }> {
+ *     boot() { this.app.make(HttpKernel).use(rateLimiter({ max: this.options.max })); }
+ *   }
+ *   app.register(RateLimitProvider, { max: 100 });
  */
 export class ServiceProvider {
     app;
-    constructor(app) {
+    options;
+    constructor(app, options = {}) {
         this.app = app;
+        this.options = options;
     }
     register() { }
     boot() { }

package/dist/core/redis.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Redis integration. Like the database and mail layers, it's built on a small
+ * pluggable driver (`RedisConnection`) rather than a hard dependency — so the
+ * core imports no client and runs on Node and the edge. Point it at Upstash
+ * (HTTP/`fetch`), ioredis, node-redis, or the built-in `MemoryRedis` for tests.
+ *
+ *   setRedis(new MemoryRedis());          // or an Upstash/ioredis adapter
+ *   await redis().set("views", "1");
+ *   await redis().incr("views");          // 2
+ *   await redis().remember("user:1", 60, () => fetchUser(1));
+ *
+ * `Redis` adds JSON helpers and a `remember` cache pattern over the raw command
+ * seam; `redisStore()` exposes it as a `CacheStore` so the cache can be
+ * Redis-backed.
+ */
+import type { CacheStore } from "./cache.js";
+export interface SetOptions {
+    /** Expire after N seconds. */
+    ex?: number;
+    /** Expire after N milliseconds. */
+    px?: number;
+}
+/** The bridge to your Redis client — implement it once per driver. */
+export interface RedisConnection {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, options?: SetOptions): Promise<void>;
+    del(...keys: string[]): Promise<number>;
+    exists(...keys: string[]): Promise<number>;
+    incrBy(key: string, amount: number): Promise<number>;
+    expire(key: string, seconds: number): Promise<boolean>;
+    ttl(key: string): Promise<number>;
+    keys(pattern: string): Promise<string[]>;
+    flushAll(): Promise<void>;
+}
+/** An in-memory `RedisConnection` with TTL support — the default; ideal for tests. */
+export declare class MemoryRedis implements RedisConnection {
+    private store;
+    private live;
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, options?: SetOptions): Promise<void>;
+    del(...keys: string[]): Promise<number>;
+    exists(...keys: string[]): Promise<number>;
+    incrBy(key: string, amount: number): Promise<number>;
+    expire(key: string, seconds: number): Promise<boolean>;
+    ttl(key: string): Promise<number>;
+    keys(pattern: string): Promise<string[]>;
+    flushAll(): Promise<void>;
+}
+export declare class Redis {
+    private conn;
+    constructor(conn: RedisConnection);
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, options?: SetOptions): Promise<void>;
+    del(...keys: string[]): Promise<number>;
+    exists(...keys: string[]): Promise<number>;
+    has(key: string): Promise<boolean>;
+    incr(key: string): Promise<number>;
+    decr(key: string): Promise<number>;
+    incrBy(key: string, amount: number): Promise<number>;
+    expire(key: string, seconds: number): Promise<boolean>;
+    ttl(key: string): Promise<number>;
+    keys(pattern?: string): Promise<string[]>;
+    flushAll(): Promise<void>;
+    /** Get a JSON value (parsed), or null if the key is unset. */
+    getJson<T>(key: string): Promise<T | null>;
+    /** Set a value as JSON. */
+    setJson(key: string, value: unknown, options?: SetOptions): Promise<void>;
+    /** Return the cached JSON value, or compute it, store it for `seconds`, and return it. */
+    remember<T>(key: string, seconds: number, factory: () => T | Promise<T>): Promise<T>;
+    /** The underlying driver, for raw access. */
+    get connection(): RedisConnection;
+}
+/** Expose a `Redis` client as a `CacheStore`, so the cache can be Redis-backed. */
+export declare function redisStore(client?: Redis): CacheStore;
+/** Register the default Redis driver used by `redis()`. */
+export declare function setRedis(conn: RedisConnection): Redis;
+/** The default Redis client. */
+export declare function redis(): Redis;

package/dist/core/redis.js

@@ -0,0 +1,176 @@
+/**
+ * Redis integration. Like the database and mail layers, it's built on a small
+ * pluggable driver (`RedisConnection`) rather than a hard dependency — so the
+ * core imports no client and runs on Node and the edge. Point it at Upstash
+ * (HTTP/`fetch`), ioredis, node-redis, or the built-in `MemoryRedis` for tests.
+ *
+ *   setRedis(new MemoryRedis());          // or an Upstash/ioredis adapter
+ *   await redis().set("views", "1");
+ *   await redis().incr("views");          // 2
+ *   await redis().remember("user:1", 60, () => fetchUser(1));
+ *
+ * `Redis` adds JSON helpers and a `remember` cache pattern over the raw command
+ * seam; `redisStore()` exposes it as a `CacheStore` so the cache can be
+ * Redis-backed.
+ */
+/* ------------------------------ memory driver ----------------------------- */
+/** An in-memory `RedisConnection` with TTL support — the default; ideal for tests. */
+export class MemoryRedis {
+    store = new Map();
+    live(key) {
+        const entry = this.store.get(key);
+        if (!entry)
+            return undefined;
+        if (entry.expires && entry.expires <= Date.now()) {
+            this.store.delete(key);
+            return undefined;
+        }
+        return entry;
+    }
+    async get(key) {
+        return this.live(key)?.value ?? null;
+    }
+    async set(key, value, options) {
+        const ms = options?.px ?? (options?.ex != null ? options.ex * 1000 : 0);
+        this.store.set(key, { value, expires: ms ? Date.now() + ms : 0 });
+    }
+    async del(...keys) {
+        let n = 0;
+        for (const key of keys)
+            if (this.store.delete(key))
+                n++;
+        return n;
+    }
+    async exists(...keys) {
+        let n = 0;
+        for (const key of keys)
+            if (this.live(key))
+                n++;
+        return n;
+    }
+    async incrBy(key, amount) {
+        const current = Number(this.live(key)?.value ?? 0);
+        const next = current + amount;
+        const expires = this.store.get(key)?.expires ?? 0;
+        this.store.set(key, { value: String(next), expires });
+        return next;
+    }
+    async expire(key, seconds) {
+        const entry = this.live(key);
+        if (!entry)
+            return false;
+        entry.expires = Date.now() + seconds * 1000;
+        return true;
+    }
+    async ttl(key) {
+        const entry = this.live(key);
+        if (!entry)
+            return -2; // no such key
+        if (!entry.expires)
+            return -1; // no expiry
+        return Math.ceil((entry.expires - Date.now()) / 1000);
+    }
+    async keys(pattern) {
+        // Glob-ish: translate `*` and `?` to a regex.
+        const rx = new RegExp("^" + pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".") + "$");
+        const out = [];
+        for (const key of this.store.keys())
+            if (this.live(key) && rx.test(key))
+                out.push(key);
+        return out;
+    }
+    async flushAll() {
+        this.store.clear();
+    }
+}
+/* -------------------------------- the client ------------------------------ */
+export class Redis {
+    conn;
+    constructor(conn) {
+        this.conn = conn;
+    }
+    get(key) {
+        return this.conn.get(key);
+    }
+    set(key, value, options) {
+        return this.conn.set(key, value, options);
+    }
+    del(...keys) {
+        return this.conn.del(...keys);
+    }
+    exists(...keys) {
+        return this.conn.exists(...keys);
+    }
+    async has(key) {
+        return (await this.conn.exists(key)) > 0;
+    }
+    incr(key) {
+        return this.conn.incrBy(key, 1);
+    }
+    decr(key) {
+        return this.conn.incrBy(key, -1);
+    }
+    incrBy(key, amount) {
+        return this.conn.incrBy(key, amount);
+    }
+    expire(key, seconds) {
+        return this.conn.expire(key, seconds);
+    }
+    ttl(key) {
+        return this.conn.ttl(key);
+    }
+    keys(pattern = "*") {
+        return this.conn.keys(pattern);
+    }
+    flushAll() {
+        return this.conn.flushAll();
+    }
+    /** Get a JSON value (parsed), or null if the key is unset. */
+    async getJson(key) {
+        const raw = await this.conn.get(key);
+        return raw == null ? null : JSON.parse(raw);
+    }
+    /** Set a value as JSON. */
+    setJson(key, value, options) {
+        return this.conn.set(key, JSON.stringify(value), options);
+    }
+    /** Return the cached JSON value, or compute it, store it for `seconds`, and return it. */
+    async remember(key, seconds, factory) {
+        const hit = await this.getJson(key);
+        if (hit !== null)
+            return hit;
+        const fresh = await factory();
+        await this.setJson(key, fresh, { ex: seconds });
+        return fresh;
+    }
+    /** The underlying driver, for raw access. */
+    get connection() {
+        return this.conn;
+    }
+}
+/* ----------------------------- cache adapter ------------------------------ */
+/** Expose a `Redis` client as a `CacheStore`, so the cache can be Redis-backed. */
+export function redisStore(client = redis()) {
+    return {
+        // The cache treats `undefined` as "miss"; Redis has no such value, so map it.
+        get: async (key) => (await client.getJson(key)) ?? undefined,
+        set: async (key, value, ttlMs) => {
+            await client.setJson(key, value, ttlMs ? { px: ttlMs } : undefined);
+        },
+        delete: async (key) => {
+            await client.del(key);
+        },
+        clear: () => client.flushAll(),
+    };
+}
+/* -------------------------------- global ---------------------------------- */
+let client = new Redis(new MemoryRedis());
+/** Register the default Redis driver used by `redis()`. */
+export function setRedis(conn) {
+    client = new Redis(conn);
+    return client;
+}
+/** The default Redis client. */
+export function redis() {
+    return client;
+}

package/dist/core/request-logger.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Per-request logging. `requestLogger()` middleware binds a child logger to each
+ * request with a generated `reqId`, so every log line within that request
+ * correlates — Fastify's `request.log`, built on Keel's `Logger.child()`. It can
+ * also log the request start and completion (method, path, status, duration).
+ *
+ *   kernel.use(requestLogger());          // in app/Http/Kernel.ts
+ *   requestLog().info("charging card");   // anywhere in the request → carries reqId
+ */
+import type { Context, MiddlewareHandler } from "hono";
+import type { Logger } from "./logger.js";
+export interface RequestLoggerOptions {
+    /** Generate the request id. Default: `crypto.randomUUID()`. */
+    genReqId?: (c: Context) => string;
+    /** Reuse an incoming id from this header if present (e.g. `"x-request-id"`). */
+    idHeader?: string;
+    /** Log request start and completion lines. Default: true. */
+    logRequests?: boolean;
+}
+/** Middleware: attach a per-request child logger (with `reqId`) and log the request. */
+export declare function requestLogger(options?: RequestLoggerOptions): MiddlewareHandler;
+/**
+ * The current request's child logger (carrying its `reqId`), or the base logger
+ * when called outside a request or without `requestLogger()` installed.
+ */
+export declare function requestLog(): Logger;

package/dist/core/request-logger.js

@@ -0,0 +1,48 @@
+/**
+ * Per-request logging. `requestLogger()` middleware binds a child logger to each
+ * request with a generated `reqId`, so every log line within that request
+ * correlates — Fastify's `request.log`, built on Keel's `Logger.child()`. It can
+ * also log the request start and completion (method, path, status, duration).
+ *
+ *   kernel.use(requestLogger());          // in app/Http/Kernel.ts
+ *   requestLog().info("charging card");   // anywhere in the request → carries reqId
+ */
+import { ctx } from "./request.js";
+import { logger } from "./helpers.js";
+// The child logger for the current request, keyed by the context object.
+const store = new WeakMap();
+/** Middleware: attach a per-request child logger (with `reqId`) and log the request. */
+export function requestLogger(options = {}) {
+    const { genReqId, idHeader, logRequests = true } = options;
+    return async (c, next) => {
+        const incoming = idHeader ? c.req.header(idHeader) : undefined;
+        const reqId = incoming ?? (genReqId ? genReqId(c) : crypto.randomUUID());
+        const log = logger().child({ reqId });
+        store.set(c, log);
+        const start = performance.now();
+        if (logRequests)
+            log.info("request", { method: c.req.method, path: c.req.path });
+        await next();
+        if (logRequests) {
+            log.info("request completed", {
+                status: c.res.status,
+                ms: Number((performance.now() - start).toFixed(1)),
+            });
+        }
+    };
+}
+/**
+ * The current request's child logger (carrying its `reqId`), or the base logger
+ * when called outside a request or without `requestLogger()` installed.
+ */
+export function requestLog() {
+    try {
+        const log = store.get(ctx());
+        if (log)
+            return log;
+    }
+    catch {
+        // not in a request context
+    }
+    return logger();
+}

package/dist/core/request.d.ts

@@ -39,6 +39,12 @@ interface ResponseHelper {
     status(code: number): ResponseHelper;
     /** Set a response header (chainable). */
     header(name: string, value: string): ResponseHelper;
+    /** Set several response headers at once (chainable). */
+    headers(map: Record<string, string>): ResponseHelper;
+    /** Read a response header set so far (e.g. in middleware after `next()`). */
+    getHeader(name: string): string | null;
+    /** Whether a response header has been set. */
+    hasHeader(name: string): boolean;
     /** Set the Content-Type (chainable). */
     type(mime: string): ResponseHelper;
     /** Append a value to a (possibly multi-value) header (chainable). */
@@ -74,13 +80,23 @@ export declare const request: {
     param(name?: string): string | Record<string, string>;
     query(name?: string): string | undefined | Record<string, string>;
     json<T = unknown>(): Promise<T>;
+    /**
+     * The raw request body as text — for content types `json()`/`all()` don't
+     * handle (XML, CSV, a custom format). Parse it yourself from here.
+     */
+    text(): Promise<string>;
+    /** The raw request body as an ArrayBuffer (binary payloads). */
+    arrayBuffer(): Promise<ArrayBuffer>;
+    /** The raw request body as a Blob. */
+    blob(): Promise<Blob>;
     /** The raw web Request. */
     readonly raw: Request;
-    /** The matched route: `{ name, pattern, methods }`. */
+    /** The matched route: `{ name, pattern, methods, config }`. */
     readonly route: {
         name?: string;
         pattern: string;
         methods: import("./index.js").Method[];
+        config: Record<string, unknown>;
     } | undefined;
     /** Whether the matched route has the given name. */
     routeIs(name: string): boolean;

package/dist/core/request.js

@@ -128,6 +128,17 @@ export const response = {
         ctx().header(name, value);
         return response;
     },
+    headers(map) {
+        for (const [name, value] of Object.entries(map))
+            ctx().header(name, value);
+        return response;
+    },
+    getHeader(name) {
+        return ctx().res.headers.get(name);
+    },
+    hasHeader(name) {
+        return ctx().res.headers.has(name);
+    },
     type(mime) {
         ctx().header("content-type", mime);
         return response;
@@ -196,11 +207,26 @@ export const request = {
     json() {
         return ctx().req.json();
     },
+    /**
+     * The raw request body as text — for content types `json()`/`all()` don't
+     * handle (XML, CSV, a custom format). Parse it yourself from here.
+     */
+    text() {
+        return ctx().req.text();
+    },
+    /** The raw request body as an ArrayBuffer (binary payloads). */
+    arrayBuffer() {
+        return ctx().req.arrayBuffer();
+    },
+    /** The raw request body as a Blob. */
+    blob() {
+        return ctx().req.blob();
+    },
     /** The raw web Request. */
     get raw() {
         return ctx().req.raw;
     },
-    /** The matched route: `{ name, pattern, methods }`. */
+    /** The matched route: `{ name, pattern, methods, config }`. */
     get route() {
         return ctx().get("route");
     },