@shaferllc/keel 0.59.0 → 0.66.0

package/dist/core/csrf.js

@@ -0,0 +1,78 @@
+/**
+ * CSRF protection for server-rendered apps. A synchronizer token lives in the
+ * session; state-changing requests (`POST`/`PUT`/`PATCH`/`DELETE`) must echo it
+ * back, or they're rejected with `419 Page Expired`. Needs `sessionMiddleware()`.
+ *
+ *   this.use(sessionMiddleware());
+ *   this.use(csrf());
+ *
+ * Put the token in forms with `csrfField()`; SPAs get it for free — `csrf()` also
+ * writes an `XSRF-TOKEN` cookie that axios/fetch libraries send back as the
+ * `X-XSRF-TOKEN` header automatically. The token is also read from a `_token` or
+ * `_csrf` field, or the `X-CSRF-Token` header.
+ */
+import { setCookie } from "hono/cookie";
+import { HttpException } from "./exceptions.js";
+import { session } from "./session.js";
+import { request } from "./request.js";
+const KEY = "_csrf";
+const UNSAFE = new Set(["POST", "PUT", "PATCH", "DELETE"]);
+function randomToken() {
+    const bytes = crypto.getRandomValues(new Uint8Array(32));
+    let s = "";
+    for (const b of bytes)
+        s += String.fromCharCode(b);
+    return btoa(s).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function safeEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    let result = 0;
+    for (let i = 0; i < a.length; i++)
+        result |= a.charCodeAt(i) ^ b.charCodeAt(i);
+    return result === 0;
+}
+/** The current request's CSRF token, minting and storing one if absent. */
+export function csrfToken() {
+    const sess = session();
+    let token = sess.get(KEY, undefined);
+    if (!token) {
+        token = randomToken();
+        sess.put(KEY, token);
+    }
+    return token;
+}
+/** A hidden form input carrying the CSRF token — drop it into any `<form method="POST">`. */
+export function csrfField() {
+    return `<input type="hidden" name="_token" value="${csrfToken()}">`;
+}
+async function submitted(c) {
+    const header = c.req.header("x-csrf-token") ?? c.req.header("x-xsrf-token");
+    if (header)
+        return header;
+    const all = await request.all(); // shares keel's body cache — safe to read
+    return (all._token ?? all._csrf);
+}
+function isExcepted(path, except) {
+    return except.some((rule) => typeof rule === "string"
+        ? rule.endsWith("*")
+            ? path.startsWith(rule.slice(0, -1))
+            : path === rule
+        : rule.test(path));
+}
+export function csrf(options = {}) {
+    const except = options.except ?? [];
+    return async (c, next) => {
+        const token = csrfToken(); // ensures a token exists in the session
+        if (options.cookie !== false) {
+            setCookie(c, "XSRF-TOKEN", token, { path: "/", sameSite: "Lax" }); // readable by JS on purpose
+        }
+        if (UNSAFE.has(c.req.method.toUpperCase()) && !isExcepted(c.req.path, except)) {
+            const provided = await submitted(c);
+            if (!provided || !safeEqual(provided, token)) {
+                throw new HttpException(419, "CSRF token mismatch");
+            }
+        }
+        await next();
+    };
+}

package/dist/core/database.d.ts

@@ -31,16 +31,40 @@ export interface Connection {
 }
 export type Dialect = "sqlite" | "mysql" | "postgres";
 export type Operator = "=" | "!=" | "<" | "<=" | ">" | ">=" | "like";
-/** Register the database connection (and dialect) used by `db()`. */
+/** A registered connection — the driver bridge plus its SQL dialect. */
+interface Source {
+    conn: Connection;
+    dialect: Dialect;
+}
+/** Register the default connection (and dialect) used by `db()`. */
 export declare function setConnection(conn: Connection, driverDialect?: Dialect): void;
+/**
+ * Register a *named* connection alongside any others — the way to use more than
+ * one database. Point a query or model at it by name; nothing else changes.
+ *
+ *   addConnection("reporting", pgConn, "postgres");
+ *   await db("events", "reporting").where("kind", "signup").count();
+ */
+export declare function addConnection(name: string, conn: Connection, driverDialect?: Dialect): void;
+/** Choose which registered connection `db()` and models use when none is named. */
+export declare function setDefaultConnection(name: string): void;
+/** The names of every registered connection. */
+export declare function connectionNames(): string[];
+/** Unregister every connection — a test helper for a clean slate. */
+export declare function clearConnections(): void;
 export declare class QueryBuilder<T extends Row = Row> {
     private table;
+    private getSource;
     private wheres;
     private orders;
     private columns;
     private _limit?;
     private _offset?;
-    constructor(table: string);
+    constructor(table: string, getSource: () => Source);
+    /** Run a row-returning query on this builder's connection, dialect-adjusted. */
+    private runSelect;
+    /** Run a write on this builder's connection, dialect-adjusted. */
+    private runWrite;
     select(...columns: string[]): this;
     where(column: string, value: unknown): this;
     where(column: string, operator: Operator, value: unknown): this;
@@ -79,5 +103,26 @@ export declare class QueryBuilder<T extends Row = Row> {
     update(data: Row): Promise<WriteResult>;
     delete(): Promise<WriteResult>;
 }
-/** Start a query against a table. */
-export declare function db<T extends Row = Row>(table: string): QueryBuilder<T>;
+/** Start a query against a table, on the default connection or a named one. */
+export declare function db<T extends Row = Row>(table: string, connectionName?: string): QueryBuilder<T>;
+/** A handle to one registered connection — query it, or run raw SQL on it. */
+export interface ConnectionHandle {
+    /** Start a query against a table on this connection. */
+    table<T extends Row = Row>(table: string): QueryBuilder<T>;
+    /** Run a raw row-returning query (`?` placeholders, dialect-adjusted). */
+    select(sql: string, bindings?: unknown[]): Promise<Row[]>;
+    /** Run a raw write (`?` placeholders, dialect-adjusted). */
+    write(sql: string, bindings?: unknown[]): Promise<WriteResult>;
+    /** This connection's SQL dialect. */
+    readonly dialect: Dialect;
+}
+/**
+ * Get a handle to a named connection (or the default). Use it to run several
+ * queries against one database without repeating the name, or to reach the raw
+ * `select`/`write` bridge.
+ *
+ *   const reporting = connection("reporting");
+ *   await reporting.table("events").where("kind", "signup").count();
+ */
+export declare function connection(name?: string): ConnectionHandle;
+export {};

package/dist/core/database.js

@@ -9,20 +9,56 @@
  *   const user = await db("users").where("id", 1).first();
  *   await db("users").insert({ email });
  */
-let connection;
-let dialect = "sqlite";
-/** Register the database connection (and dialect) used by `db()`. */
+/**
+ * The connection registry. An app can talk to several databases at once —
+ * register each by name, then route a query with `db(table, name)`, a whole
+ * model with `static connection`, or a handle from `connection(name)`. The
+ * unnamed default lives under `"default"` so `db(table)` and `setConnection()`
+ * keep working unchanged.
+ */
+const registry = new Map();
+let defaultConnection = "default";
+/** Register the default connection (and dialect) used by `db()`. */
 export function setConnection(conn, driverDialect = "sqlite") {
-    connection = conn;
-    dialect = driverDialect;
+    registry.set("default", { conn, dialect: driverDialect });
+    defaultConnection = "default";
+}
+/**
+ * Register a *named* connection alongside any others — the way to use more than
+ * one database. Point a query or model at it by name; nothing else changes.
+ *
+ *   addConnection("reporting", pgConn, "postgres");
+ *   await db("events", "reporting").where("kind", "signup").count();
+ */
+export function addConnection(name, conn, driverDialect = "sqlite") {
+    registry.set(name, { conn, dialect: driverDialect });
+}
+/** Choose which registered connection `db()` and models use when none is named. */
+export function setDefaultConnection(name) {
+    if (!registry.has(name))
+        throw new Error(`No database connection "${name}" to make default.`);
+    defaultConnection = name;
+}
+/** The names of every registered connection. */
+export function connectionNames() {
+    return [...registry.keys()];
 }
-function conn() {
-    if (!connection)
-        throw new Error("No database connection. Call setConnection(conn, dialect).");
-    return connection;
+/** Unregister every connection — a test helper for a clean slate. */
+export function clearConnections() {
+    registry.clear();
+    defaultConnection = "default";
 }
-/** Render `?` placeholders for the active dialect (Postgres uses $1, $2, …). */
-function placeholders(sql) {
+/** Resolve a connection by name (or the default); throws if it isn't registered. */
+function resolve(name) {
+    const source = registry.get(name ?? defaultConnection);
+    if (!source) {
+        throw new Error(`No database connection${name ? ` "${name}"` : ""}. ` +
+            `Call setConnection(conn, dialect) or addConnection(name, conn, dialect).`);
+    }
+    return source;
+}
+/** Render `?` placeholders for a dialect (Postgres uses $1, $2, …). */
+function placeholders(sql, dialect) {
     if (dialect !== "postgres")
         return sql;
     let i = 0;
@@ -30,13 +66,28 @@ function placeholders(sql) {
 }
 export class QueryBuilder {
     table;
+    getSource;
     wheres = [];
     orders = [];
     columns = "*";
     _limit;
     _offset;
-    constructor(table) {
+    // The connection is resolved lazily, when a query actually runs — so building
+    // a query never throws, and an unregistered connection surfaces as a rejected
+    // read/write rather than a synchronous error at construction.
+    constructor(table, getSource) {
         this.table = table;
+        this.getSource = getSource;
+    }
+    /** Run a row-returning query on this builder's connection, dialect-adjusted. */
+    runSelect(sql, bindings) {
+        const source = this.getSource();
+        return source.conn.select(placeholders(sql, source.dialect), bindings);
+    }
+    /** Run a write on this builder's connection, dialect-adjusted. */
+    runWrite(sql, bindings) {
+        const source = this.getSource();
+        return source.conn.write(placeholders(sql, source.dialect), bindings);
     }
     select(...columns) {
         this.columns = columns.length ? columns.join(", ") : "*";
@@ -114,7 +165,7 @@ export class QueryBuilder {
             sql += ` LIMIT ${this._limit}`;
         if (this._offset != null)
             sql += ` OFFSET ${this._offset}`;
-        return (await conn().select(placeholders(sql), where.bindings));
+        return (await this.runSelect(sql, where.bindings));
     }
     async first() {
         this._limit = 1;
@@ -123,7 +174,7 @@ export class QueryBuilder {
     }
     async count() {
         const where = this.whereClause();
-        const rows = (await conn().select(placeholders(`SELECT COUNT(*) AS count FROM ${this.table}${where.sql}`), where.bindings));
+        const rows = (await this.runSelect(`SELECT COUNT(*) AS count FROM ${this.table}${where.sql}`, where.bindings));
         return Number(rows[0]?.count ?? 0);
     }
     async exists() {
@@ -131,7 +182,7 @@ export class QueryBuilder {
     }
     async aggregate(fn, column) {
         const where = this.whereClause();
-        const rows = (await conn().select(placeholders(`SELECT ${fn}(${column}) AS agg FROM ${this.table}${where.sql}`), where.bindings));
+        const rows = (await this.runSelect(`SELECT ${fn}(${column}) AS agg FROM ${this.table}${where.sql}`, where.bindings));
         return Number(rows[0]?.agg ?? 0);
     }
     sum(column) {
@@ -178,7 +229,7 @@ export class QueryBuilder {
         const sql = `INSERT INTO ${this.table} (${keys.join(", ")}) VALUES (${keys
             .map(() => "?")
             .join(", ")})`;
-        return conn().write(placeholders(sql), Object.values(data));
+        return this.runWrite(sql, Object.values(data));
     }
     async insertGetId(data) {
         return (await this.insert(data)).insertId;
@@ -187,17 +238,34 @@ export class QueryBuilder {
         const keys = Object.keys(data);
         const set = keys.map((k) => `${k} = ?`).join(", ");
         const where = this.whereClause();
-        return conn().write(placeholders(`UPDATE ${this.table} SET ${set}${where.sql}`), [
+        return this.runWrite(`UPDATE ${this.table} SET ${set}${where.sql}`, [
             ...Object.values(data),
             ...where.bindings,
         ]);
     }
     async delete() {
         const where = this.whereClause();
-        return conn().write(placeholders(`DELETE FROM ${this.table}${where.sql}`), where.bindings);
+        return this.runWrite(`DELETE FROM ${this.table}${where.sql}`, where.bindings);
     }
 }
-/** Start a query against a table. */
-export function db(table) {
-    return new QueryBuilder(table);
+/** Start a query against a table, on the default connection or a named one. */
+export function db(table, connectionName) {
+    return new QueryBuilder(table, () => resolve(connectionName));
+}
+/**
+ * Get a handle to a named connection (or the default). Use it to run several
+ * queries against one database without repeating the name, or to reach the raw
+ * `select`/`write` bridge.
+ *
+ *   const reporting = connection("reporting");
+ *   await reporting.table("events").where("kind", "signup").count();
+ */
+export function connection(name) {
+    const source = resolve(name);
+    return {
+        table: (t) => new QueryBuilder(t, () => source),
+        select: (sql, bindings = []) => source.conn.select(placeholders(sql, source.dialect), bindings),
+        write: (sql, bindings = []) => source.conn.write(placeholders(sql, source.dialect), bindings),
+        dialect: source.dialect,
+    };
 }

package/dist/core/helpers.d.ts

@@ -38,6 +38,12 @@ export declare function instance<T>(token: Token<T>, value: T): T;
 export declare function make<T>(token: Token<T>): T;
 /** Whether a token is bound or has a cached instance. */
 export declare function bound(token: Token): boolean;
+/** Register an alias token that resolves to another token. */
+export declare function alias<T>(aliasToken: Token<T>, target: Token<T>): void;
+/** Temporarily replace a binding with a fake (tests). Undo with `restore()`. */
+export declare function swap<T>(token: Token<T>, factory: Factory<T>): void;
+/** Undo a `swap()` — restore the original binding. No token restores every swap. */
+export declare function restore(token?: Token): void;
 /** The application's event emitter. */
 export declare function events(): Events;
 /** Emit an event, awaiting every listener. */

package/dist/core/helpers.js

@@ -65,6 +65,18 @@ export function make(token) {
 export function bound(token) {
     return app().bound(token);
 }
+/** Register an alias token that resolves to another token. */
+export function alias(aliasToken, target) {
+    app().alias(aliasToken, target);
+}
+/** Temporarily replace a binding with a fake (tests). Undo with `restore()`. */
+export function swap(token, factory) {
+    app().swap(token, factory);
+}
+/** Undo a `swap()` — restore the original binding. No token restores every swap. */
+export function restore(token) {
+    app().restore(token);
+}
 /* ------------------------------- events -------------------------------- */
 /** The application's event emitter. */
 export function events() {

package/dist/core/index.d.ts

@@ -4,7 +4,7 @@ export type { Token, Constructor, Factory } from "./container.js";
 export { Application } from "./application.js";
 export type { BootOptions, LifecycleHook, Configurator } from "./application.js";
 export { Config, env } from "./config.js";
-export { app, config, view, bind, singleton, instance, make, bound, events, emit, listen, cache, logger, onReady, onShutdown, terminate, } from "./helpers.js";
+export { app, config, view, bind, singleton, instance, make, bound, alias, swap, restore, events, emit, listen, cache, logger, onReady, onShutdown, terminate, } from "./helpers.js";
 export { Logger } from "./logger.js";
 export type { LogLevel, LoggerOptions } from "./logger.js";
 export { requestLogger, requestLog } from "./request-logger.js";
@@ -19,11 +19,17 @@ export { Storage, MemoryDisk, storage, setDisk } from "./storage.js";
 export type { Disk, Contents } from "./storage.js";
 export { dump, dd } from "./debug.js";
 export { hash, encryption, jwt } from "./crypto.js";
-export type { JwtPayload, JwtSignOptions, JwtVerifyOptions } from "./crypto.js";
+export type { JwtPayload, JwtSignOptions, JwtVerifyOptions, EncryptOptions } from "./crypto.js";
 export { rateLimiter } from "./rate-limit.js";
 export type { RateLimiterOptions } from "./rate-limit.js";
-export { db, setConnection, QueryBuilder } from "./database.js";
-export type { Connection, WriteResult, Row, Dialect, Operator, Paginated } from "./database.js";
+export { cors } from "./cors.js";
+export type { CorsOptions } from "./cors.js";
+export { securityHeaders } from "./shield.js";
+export type { SecurityHeadersOptions, HstsOptions } from "./shield.js";
+export { csrf, csrfToken, csrfField } from "./csrf.js";
+export type { CsrfOptions } from "./csrf.js";
+export { db, connection, setConnection, addConnection, setDefaultConnection, connectionNames, clearConnections, QueryBuilder, } from "./database.js";
+export type { Connection, ConnectionHandle, WriteResult, Row, Dialect, Operator, Paginated } from "./database.js";
 export { Model } from "./model.js";
 export type { CastType, Casts } from "./casts.js";
 export { Relation, HasOne, HasMany, BelongsTo, BelongsToMany } from "./relations.js";
@@ -63,10 +69,14 @@ export { validate, validateRequest, validated } from "./validation.js";
 export type { Schema, RequestSchemas } from "./validation.js";
 export { Session, session, sessionMiddleware } from "./session.js";
 export type { SessionOptions } from "./session.js";
-export { Auth, auth, authGuard, bearerAuth, setUserProvider } from "./auth.js";
-export type { UserProvider } from "./auth.js";
-export { define, policy, gateBefore, setUserResolver, clearAuthorization, can, cannot, canFor, authorize, authorizeFor, } from "./authorization.js";
-export type { GateCallback, BeforeCallback } from "./authorization.js";
+export { Auth, auth, authGuard, bearerAuth, basicAuth, tokenAuth, token, tokenCan, setUserProvider } from "./auth.js";
+export type { UserProvider, BasicVerifier } from "./auth.js";
+export { createToken, verifyToken, revokeToken, revokeTokens, listTokens, tokenAllows, tokenDenies, setTokensTable, } from "./tokens.js";
+export type { AccessToken, CreateTokenOptions, IssuedToken } from "./tokens.js";
+export { social, github, google, discord, oauthDriver, oauthState, OAuthDriver, OAuthError, twitter, oauth1Driver, oauth1Signature, OAuth1Driver, } from "./social.js";
+export type { SocialUser, OAuthToken, OAuthConfig, ProviderSpec, RedirectOptions, OAuth1Config, OAuth1Token, OAuth1ProviderSpec, } from "./social.js";
+export { define, policy, gateBefore, gateAfter, setUserResolver, clearAuthorization, can, cannot, canFor, authorize, authorizeFor, } from "./authorization.js";
+export type { GateCallback, BeforeCallback, AfterCallback } from "./authorization.js";
 export { Transformer } from "./transformer.js";
 export type { Attributes, DocumentOptions } from "./transformer.js";
 export { Broker, Service, LocalTransporter, ServiceNotFoundError, RequestTimeoutError, broker, setBroker, } from "./broker.js";

package/dist/core/index.js

@@ -2,7 +2,7 @@
 export { Container } from "./container.js";
 export { Application } from "./application.js";
 export { Config, env } from "./config.js";
-export { app, config, view, bind, singleton, instance, make, bound, events, emit, listen, cache, logger, onReady, onShutdown, terminate, } from "./helpers.js";
+export { app, config, view, bind, singleton, instance, make, bound, alias, swap, restore, events, emit, listen, cache, logger, onReady, onShutdown, terminate, } from "./helpers.js";
 export { Logger } from "./logger.js";
 export { requestLogger, requestLog } from "./request-logger.js";
 export { Events } from "./events.js";
@@ -12,7 +12,10 @@ export { Storage, MemoryDisk, storage, setDisk } from "./storage.js";
 export { dump, dd } from "./debug.js";
 export { hash, encryption, jwt } from "./crypto.js";
 export { rateLimiter } from "./rate-limit.js";
-export { db, setConnection, QueryBuilder } from "./database.js";
+export { cors } from "./cors.js";
+export { securityHeaders } from "./shield.js";
+export { csrf, csrfToken, csrfField } from "./csrf.js";
+export { db, connection, setConnection, addConnection, setDefaultConnection, connectionNames, clearConnections, QueryBuilder, } from "./database.js";
 export { Model } from "./model.js";
 export { Relation, HasOne, HasMany, BelongsTo, BelongsToMany } from "./relations.js";
 export { Faker, Factory as ModelFactory, factory, Seeder, seed } from "./factory.js";
@@ -35,8 +38,10 @@ export { TestClient, TestResponse, testClient } from "./testing.js";
 export { HttpException, BadRequestException, UnauthorizedException, PaymentRequiredException, ForbiddenException, NotFoundException, MethodNotAllowedException, NotAcceptableException, RequestTimeoutException, ConflictException, LengthRequiredException, ValidationException, TooManyRequestsException, ServerErrorException, NotImplementedException, BadGatewayException, ServiceUnavailableException, createError, STATUS_TEXT, } from "./exceptions.js";
 export { validate, validateRequest, validated } from "./validation.js";
 export { Session, session, sessionMiddleware } from "./session.js";
-export { Auth, auth, authGuard, bearerAuth, setUserProvider } from "./auth.js";
-export { define, policy, gateBefore, setUserResolver, clearAuthorization, can, cannot, canFor, authorize, authorizeFor, } from "./authorization.js";
+export { Auth, auth, authGuard, bearerAuth, basicAuth, tokenAuth, token, tokenCan, setUserProvider } from "./auth.js";
+export { createToken, verifyToken, revokeToken, revokeTokens, listTokens, tokenAllows, tokenDenies, setTokensTable, } from "./tokens.js";
+export { social, github, google, discord, oauthDriver, oauthState, OAuthDriver, OAuthError, twitter, oauth1Driver, oauth1Signature, OAuth1Driver, } from "./social.js";
+export { define, policy, gateBefore, gateAfter, setUserResolver, clearAuthorization, can, cannot, canFor, authorize, authorizeFor, } from "./authorization.js";
 export { Transformer } from "./transformer.js";
 export { Broker, Service, LocalTransporter, ServiceNotFoundError, RequestTimeoutError, broker, setBroker, } from "./broker.js";
 export { Vite, viteTags, viteAsset, viteReactRefresh } from "./vite.js";

package/dist/core/model.d.ts

@@ -22,6 +22,8 @@ type ModelClass<T extends Model> = (new (attributes?: Row) => T) & typeof Model;
 export declare class Model {
     static table: string;
     static primaryKey: string;
+    /** Which registered connection this model uses; the default when unset. */
+    static connection: string | undefined;
     /** Columns mass-assignable via `create`/`fill` (allowlist). */
     static fillable: string[];
     /** Columns NOT mass-assignable (denylist). Ignored when `fillable` is set. */

package/dist/core/model.js

@@ -34,6 +34,8 @@ function serialize(value) {
 export class Model {
     static table = "";
     static primaryKey = "id";
+    /** Which registered connection this model uses; the default when unset. */
+    static connection = undefined;
     /** Columns mass-assignable via `create`/`fill` (allowlist). */
     static fillable = [];
     /** Columns NOT mass-assignable (denylist). Ignored when `fillable` is set. */
@@ -51,7 +53,7 @@ export class Model {
     /* ------------------------------ static -------------------------------- */
     /** A raw query builder scoped to this model's table. */
     static query() {
-        return db(this.table);
+        return db(this.table, this.connection);
     }
     /** Keep only the attributes mass-assignment allows (fillable / guarded). */
     static filterFillable(attributes) {
@@ -86,11 +88,11 @@ export class Model {
         return out;
     }
     static async all() {
-        const rows = await db(this.table).get();
+        const rows = await db(this.table, this.connection).get();
         return rows.map((row) => new this(row));
     }
     static async find(id) {
-        const row = await db(this.table).where(this.primaryKey, id).first();
+        const row = await db(this.table, this.connection).where(this.primaryKey, id).first();
         return row ? new this(row) : null;
     }
     static async findOrFail(id) {
@@ -100,18 +102,18 @@ export class Model {
         return model;
     }
     static async first() {
-        const row = await db(this.table).first();
+        const row = await db(this.table, this.connection).first();
         return row ? new this(row) : null;
     }
     /** Fetch models matching a simple equality condition. */
     static async where(column, value) {
-        const rows = await db(this.table).where(column, value).get();
+        const rows = await db(this.table, this.connection).where(column, value).get();
         return rows.map((row) => new this(row));
     }
     static async create(attributes) {
         const filtered = this.filterFillable(attributes);
         const write = this.stampTimestamps(this.toDatabase(filtered), true);
-        const id = await db(this.table).insertGetId(write);
+        const id = await db(this.table, this.connection).insertGetId(write);
         const model = new this(filtered);
         if (this.timestamps) {
             model[this.createdAtColumn] = write[this.createdAtColumn];
@@ -123,7 +125,7 @@ export class Model {
     }
     /** A page of models plus pagination metadata. */
     static async paginate(page = 1, perPage = 15) {
-        const result = await db(this.table).paginate(page, perPage);
+        const result = await db(this.table, this.connection).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 }`. */
@@ -145,7 +147,7 @@ export class Model {
     }
     /** A query scoped to every column/value in `match`. */
     static matching(match) {
-        let q = db(this.table);
+        let q = db(this.table, this.connection);
         for (const [column, value] of Object.entries(match))
             q = q.where(column, value);
         return q;
@@ -209,7 +211,7 @@ export class Model {
     /** Insert (no primary key) or update (has one). */
     async save() {
         const ctor = this.ctor();
-        const { table, primaryKey } = ctor;
+        const { table, primaryKey, connection } = ctor;
         const idValue = this[primaryKey];
         const forInsert = idValue == null;
         const data = ctor.stampTimestamps(ctor.toDatabase({ ...this }), forInsert);
@@ -221,10 +223,10 @@ export class Model {
         }
         delete data[primaryKey];
         if (!forInsert) {
-            await db(table).where(primaryKey, idValue).update(data);
+            await db(table, connection).where(primaryKey, idValue).update(data);
         }
         else {
-            const id = await db(table).insertGetId(data);
+            const id = await db(table, connection).insertGetId(data);
             if (id != null)
                 this[primaryKey] = id;
         }
@@ -237,14 +239,14 @@ export class Model {
     /** 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();
+        const row = await db(ctor.table, ctor.connection).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();
+        const { table, primaryKey, connection } = this.ctor();
+        await db(table, connection).where(primaryKey, this[primaryKey]).delete();
     }
     /** Merge mass-assignable attributes into the model (cast, not saved). */
     fill(attributes) {

package/dist/core/provider.d.ts

@@ -6,6 +6,11 @@
  *             here — nothing is guaranteed to be registered yet.
  * boot():     called after every provider has registered. Safe to resolve
  *             and wire things together here.
+ * ready():    called once the whole app has booted (after every provider's
+ *             boot() and any onReady hooks). For work that needs a fully-live
+ *             app — attaching to the running server, warming a cache.
+ * shutdown(): called during graceful termination, in reverse registration
+ *             order (LIFO). Close connections, flush queues, cancel timers.
  *
  * Register with options to make a provider reusable:
  *
@@ -21,5 +26,7 @@ export declare abstract class ServiceProvider<O = Record<string, unknown>> {
     constructor(app: Application, options?: O);
     register(): void | Promise<void>;
     boot(): void | Promise<void>;
+    ready(): void | Promise<void>;
+    shutdown(): void | Promise<void>;
 }
 export type ProviderClass = new (app: Application, options?: any) => ServiceProvider;

package/dist/core/provider.js

@@ -6,6 +6,11 @@
  *             here — nothing is guaranteed to be registered yet.
  * boot():     called after every provider has registered. Safe to resolve
  *             and wire things together here.
+ * ready():    called once the whole app has booted (after every provider's
+ *             boot() and any onReady hooks). For work that needs a fully-live
+ *             app — attaching to the running server, warming a cache.
+ * shutdown(): called during graceful termination, in reverse registration
+ *             order (LIFO). Close connections, flush queues, cancel timers.
  *
  * Register with options to make a provider reusable:
  *
@@ -23,4 +28,6 @@ export class ServiceProvider {
     }
     register() { }
     boot() { }
+    ready() { }
+    shutdown() { }
 }

package/dist/core/rate-limit.js

@@ -35,10 +35,12 @@ export function rateLimiter(options = {}) {
         }
         bucket.count++;
         const remaining = Math.max(0, max - bucket.count);
+        const resetSeconds = Math.ceil(bucket.reset / 1000);
         if (bucket.count > max) {
             return c.json({ error: options.message ?? "Too Many Requests", status: 429 }, 429, {
                 "X-RateLimit-Limit": String(max),
                 "X-RateLimit-Remaining": "0",
+                "X-RateLimit-Reset": String(resetSeconds),
                 "Retry-After": String(Math.ceil((bucket.reset - now) / 1000)),
             });
         }
@@ -46,5 +48,6 @@ export function rateLimiter(options = {}) {
         // Set headers on the final response (survives any handler type).
         c.header("X-RateLimit-Limit", String(max));
         c.header("X-RateLimit-Remaining", String(remaining));
+        c.header("X-RateLimit-Reset", String(resetSeconds));
     };
 }