@shaferllc/keel 0.68.0 → 0.77.0

package/dist/core/database.js

@@ -9,6 +9,38 @@
  *   const user = await db("users").where("id", 1).first();
  *   await db("users").insert({ email });
  */
+import { AsyncLocalStorage } from "node:async_hooks";
+import { instrument, currentRequestId } from "./instrumentation.js";
+/**
+ * Run a row-returning query on a source and report it to the instrumentation
+ * stream (`db.query`) once it settles. Emitting here — the one place every
+ * builder and raw handle funnels through — means a package can watch every query
+ * without the query layer knowing anything about it.
+ */
+async function selectOn(source, sql, bindings) {
+    const start = Date.now();
+    const rows = await source.conn.select(placeholders(sql, source.dialect), bindings);
+    reportQuery("select", sql, bindings, source, start);
+    return rows;
+}
+/** Run a write on a source and report it to the instrumentation stream. */
+async function writeOn(source, sql, bindings) {
+    const start = Date.now();
+    const result = await source.conn.write(placeholders(sql, source.dialect), bindings);
+    reportQuery("write", sql, bindings, source, start);
+    return result;
+}
+function reportQuery(kind, sql, bindings, source, start) {
+    const requestId = currentRequestId();
+    instrument("db.query", {
+        sql,
+        bindings,
+        durationMs: Date.now() - start,
+        connection: source.name,
+        kind,
+        ...(requestId ? { requestId } : {}),
+    });
+}
 /**
  * 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
@@ -20,7 +52,7 @@ const registry = new Map();
 let defaultConnection = "default";
 /** Register the default connection (and dialect) used by `db()`. */
 export function setConnection(conn, driverDialect = "sqlite") {
-    registry.set("default", { conn, dialect: driverDialect });
+    registry.set("default", { name: "default", conn, dialect: driverDialect });
     defaultConnection = "default";
 }
 /**
@@ -31,7 +63,7 @@ export function setConnection(conn, driverDialect = "sqlite") {
  *   await db("events", "reporting").where("kind", "signup").count();
  */
 export function addConnection(name, conn, driverDialect = "sqlite") {
-    registry.set(name, { conn, dialect: driverDialect });
+    registry.set(name, { name, conn, dialect: driverDialect });
 }
 /** Choose which registered connection `db()` and models use when none is named. */
 export function setDefaultConnection(name) {
@@ -48,8 +80,17 @@ export function clearConnections() {
     registry.clear();
     defaultConnection = "default";
 }
-/** Resolve a connection by name (or the default); throws if it isn't registered. */
-function resolve(name) {
+/**
+ * The transactions open on the *current async context*, keyed by connection name.
+ *
+ * This is what makes an ambient transaction work: `db("users")` inside
+ * `transaction(...)` resolves to the transaction's connection without anyone
+ * passing it down. `AsyncLocalStorage` (not a module global) is what keeps two
+ * concurrent requests from stealing each other's transaction.
+ */
+const openTransactions = new AsyncLocalStorage();
+/** The registered connection under a name — ignoring any open transaction. */
+function lookup(name) {
     const source = registry.get(name ?? defaultConnection);
     if (!source) {
         throw new Error(`No database connection${name ? ` "${name}"` : ""}. ` +
@@ -57,6 +98,15 @@ function resolve(name) {
     }
     return source;
 }
+/**
+ * Resolve a connection by name (or the default); throws if it isn't registered.
+ * A transaction open on that connection wins — that's the ambient part.
+ */
+function resolve(name) {
+    const key = name ?? defaultConnection;
+    const open = openTransactions.getStore()?.get(key);
+    return open ? open.source : lookup(key);
+}
 /** Render `?` placeholders for a dialect (Postgres uses $1, $2, …). */
 function placeholders(sql, dialect) {
     if (dialect !== "postgres")
@@ -81,13 +131,11 @@ export class QueryBuilder {
     }
     /** 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);
+        return selectOn(this.getSource(), sql, 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);
+        return writeOn(this.getSource(), sql, bindings);
     }
     select(...columns) {
         this.columns = columns.length ? columns.join(", ") : "*";
@@ -252,20 +300,131 @@ export class QueryBuilder {
 export function db(table, connectionName) {
     return new QueryBuilder(table, () => resolve(connectionName));
 }
+function handleFor(source, depth, rollback) {
+    return {
+        table: (t) => new QueryBuilder(t, () => source),
+        select: (sql, bindings = []) => selectOn(source, sql, bindings),
+        write: (sql, bindings = []) => writeOn(source, sql, bindings),
+        dialect: source.dialect,
+        depth,
+        rollback,
+    };
+}
+/** Open a transaction: the driver's own if it has one, else BEGIN on what we have. */
+async function begin(source) {
+    if (source.conn.begin) {
+        const tx = await source.conn.begin();
+        return {
+            source: { name: source.name, conn: tx, dialect: source.dialect },
+            commit: () => tx.commit(),
+            rollback: () => tx.rollback(),
+        };
+    }
+    await writeOn(source, "BEGIN", []);
+    return {
+        source,
+        commit: async () => void (await writeOn(source, "COMMIT", [])),
+        rollback: async () => void (await writeOn(source, "ROLLBACK", [])),
+    };
+}
 /**
- * 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.
+ * Run `fn` inside a database transaction. It commits when `fn` returns, and
+ * **rolls back if `fn` throws** — which is the entire point: two related writes
+ * either both land or neither does, so a failure between them can't leave the row
+ * charged and the order missing.
+ *
+ *   await transaction(async () => {
+ *     await db("orders").insert(order);
+ *     await db("stock").where("id", id).decrement("count");   // a throw here undoes the insert
+ *   });
+ *
+ * Queries inside are **ambient**: `db()`, models, and relations all pick up the
+ * transaction's connection without being handed it. The callback also gets an
+ * explicit handle if you'd rather be obvious about it:
+ *
+ *   await transaction(async (tx) => {
+ *     await tx.table("orders").insert(order);
+ *   });
  *
- *   const reporting = connection("reporting");
- *   await reporting.table("events").where("kind", "signup").count();
+ * **Nesting uses savepoints.** A `transaction()` inside another doesn't open a
+ * second transaction — databases don't have those — it takes a savepoint, so an
+ * inner failure rolls back only the inner work and the outer transaction carries
+ * on. Without that, a nested helper's failure would silently abandon its caller's
+ * writes too.
  */
+export async function transaction(fn, connectionName) {
+    const key = connectionName ?? defaultConnection;
+    const store = openTransactions.getStore();
+    const open = store?.get(key);
+    /* ----------------------------- nested: savepoint ---------------------- */
+    if (open) {
+        const depth = open.depth + 1;
+        const name = `keel_sp_${depth}`;
+        const source = open.source;
+        await writeOn(source, `SAVEPOINT ${name}`, []);
+        const nested = new Map(store);
+        nested.set(key, { source, depth });
+        let undone = false;
+        const undo = async () => {
+            undone = true;
+            await writeOn(source, `ROLLBACK TO SAVEPOINT ${name}`, []);
+        };
+        try {
+            const result = await openTransactions.run(nested, () => fn(handleFor(source, depth, undo)));
+            if (!undone)
+                await writeOn(source, `RELEASE SAVEPOINT ${name}`, []);
+            return result;
+        }
+        catch (error) {
+            // Only this savepoint is undone — the transaction around it survives.
+            if (!undone)
+                await writeOn(source, `ROLLBACK TO SAVEPOINT ${name}`, []);
+            throw error;
+        }
+    }
+    /* ---------------------------- outermost ------------------------------- */
+    const tx = await begin(lookup(key));
+    const next = new Map(store ?? []);
+    next.set(key, { source: tx.source, depth: 0 });
+    let undone = false;
+    const undo = async () => {
+        undone = true;
+        await tx.rollback();
+    };
+    try {
+        const result = await openTransactions.run(next, () => fn(handleFor(tx.source, 0, undo)));
+        if (!undone)
+            await tx.commit();
+        return result;
+    }
+    catch (error) {
+        if (!undone) {
+            // A rollback that itself fails must not replace the error that caused it —
+            // that's how you end up debugging the wrong problem.
+            await tx.rollback().catch(() => { });
+        }
+        throw error;
+    }
+}
+/** Whether a transaction is open on this connection in the current context. */
+export function inTransaction(connectionName) {
+    return openTransactions.getStore()?.has(connectionName ?? defaultConnection) ?? false;
+}
 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),
+        select: (sql, bindings = []) => selectOn(source, sql, bindings),
+        write: (sql, bindings = []) => writeOn(source, sql, bindings),
         dialect: source.dialect,
     };
 }
+/**
+ * The raw driver bridge and dialect for a connection (or the default) — what the
+ * `Migrator` needs. Unlike `connection()`, this hands back the unadjusted
+ * `Connection` so the migrator can apply its own placeholder conversion.
+ */
+export function getConnection(name) {
+    const source = resolve(name);
+    return { connection: source.conn, dialect: source.dialect, name: source.name };
+}

package/dist/core/env.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Validate the environment **at boot**, not at 3am.
+ *
+ *   // config/env.ts
+ *   export const env = defineEnv({
+ *     APP_KEY: envVar.string({ required: true }),
+ *     PORT: envVar.number({ default: 3000 }),
+ *     NODE_ENV: envVar.enum(["development", "test", "production"], { default: "development" }),
+ *     DATABASE_URL: envVar.url({ required: true }),
+ *     DEBUG: envVar.boolean({ default: false }),
+ *   });
+ *
+ *   env.PORT;      // number — not "3000", and not string | undefined
+ *   env.NODE_ENV;  // "development" | "test" | "production"
+ *
+ * The plain `env("KEY")` helper hands back whatever is (or isn't) in
+ * `process.env` — so a missing `DATABASE_URL` boots a perfectly healthy-looking
+ * app that dies on the first request that needs it, in production, at night. This
+ * checks the whole environment up front and **refuses to start** otherwise.
+ *
+ * It reports **every** problem at once, not the first one. Fixing a deploy one
+ * missing variable per restart is its own small hell.
+ */
+export type EnvType = "string" | "number" | "boolean" | "enum" | "url";
+export interface EnvRule<T = unknown> {
+    readonly type: EnvType;
+    readonly required: boolean;
+    readonly default?: T;
+    readonly description?: string;
+    /** For `enum`. */
+    readonly values?: readonly string[];
+    /** Reject a value with a reason. */
+    readonly validate?: (value: T) => true | string;
+    /** @internal — carries the value type. */
+    readonly __value?: T;
+}
+interface RuleOptions<T> {
+    required?: boolean;
+    default?: T;
+    description?: string;
+    validate?: (value: T) => true | string;
+}
+/** Present unless it's explicitly optional with no default. */
+type Present<O> = O extends {
+    required: true;
+} ? true : O extends {
+    default: unknown;
+} ? true : O extends {
+    required: false;
+} ? false : false;
+type Value<O, T> = Present<O> extends true ? T : T | undefined;
+/** The rules a variable can be held to. */
+export declare const envVar: {
+    string<O extends RuleOptions<string> = Record<never, never>>(options?: O & RuleOptions<string>): EnvRule<Value<O, string>>;
+    number<O extends RuleOptions<number> = Record<never, never>>(options?: O & RuleOptions<number>): EnvRule<Value<O, number>>;
+    /** `true`/`false`/`1`/`0`/`yes`/`no`. */
+    boolean<O extends RuleOptions<boolean> = Record<never, never>>(options?: O & RuleOptions<boolean>): EnvRule<Value<O, boolean>>;
+    /** One of a fixed set — the value is typed as the union, not `string`. */
+    enum<const V extends readonly string[], O extends RuleOptions<V[number]> = Record<never, never>>(values: V, options?: O & RuleOptions<V[number]>): EnvRule<Value<O, V[number]>>;
+    /** A string that must parse as a URL — catches a truncated connection string. */
+    url<O extends RuleOptions<string> = Record<never, never>>(options?: O & RuleOptions<string>): EnvRule<Value<O, string>>;
+};
+/**
+ * The shape a schema must have.
+ *
+ * `any` rather than `unknown` on purpose: `EnvRule<T>` has `validate(value: T)`,
+ * which puts `T` in a *parameter* position and so makes the type invariant — an
+ * `EnvRule<string>` isn't assignable to an `EnvRule<unknown>`. This is the
+ * standard escape hatch for a schema constraint; the *values* stay fully typed,
+ * which is what actually matters (see `EnvValues`).
+ */
+export type EnvSchema = Record<string, EnvRule<any>>;
+/** The values a schema produces — where `env.PORT: number` comes from. */
+export type EnvValues<S extends EnvSchema> = {
+    readonly [K in keyof S]: S[K] extends {
+        __value?: infer V;
+    } ? V : never;
+};
+/** Thrown when the environment doesn't satisfy the schema. Lists every problem. */
+export declare class EnvValidationError extends Error {
+    readonly problems: string[];
+    constructor(problems: string[]);
+}
+export interface DefineEnvOptions {
+    /** Where to read from. Default: `process.env`. */
+    source?: Record<string, string | undefined>;
+}
+/**
+ * Validate the environment against a schema and return the typed, frozen values.
+ * Throws `EnvValidationError` listing **every** problem if it doesn't hold.
+ *
+ * Call it at module scope in `config/env.ts` so an invalid environment fails the
+ * boot — loudly, immediately, and with the whole list.
+ */
+export declare function defineEnv<const S extends EnvSchema>(schema: S, options?: DefineEnvOptions): EnvValues<S>;
+export {};

package/dist/core/env.js

@@ -0,0 +1,140 @@
+/**
+ * Validate the environment **at boot**, not at 3am.
+ *
+ *   // config/env.ts
+ *   export const env = defineEnv({
+ *     APP_KEY: envVar.string({ required: true }),
+ *     PORT: envVar.number({ default: 3000 }),
+ *     NODE_ENV: envVar.enum(["development", "test", "production"], { default: "development" }),
+ *     DATABASE_URL: envVar.url({ required: true }),
+ *     DEBUG: envVar.boolean({ default: false }),
+ *   });
+ *
+ *   env.PORT;      // number — not "3000", and not string | undefined
+ *   env.NODE_ENV;  // "development" | "test" | "production"
+ *
+ * The plain `env("KEY")` helper hands back whatever is (or isn't) in
+ * `process.env` — so a missing `DATABASE_URL` boots a perfectly healthy-looking
+ * app that dies on the first request that needs it, in production, at night. This
+ * checks the whole environment up front and **refuses to start** otherwise.
+ *
+ * It reports **every** problem at once, not the first one. Fixing a deploy one
+ * missing variable per restart is its own small hell.
+ */
+/** The rules a variable can be held to. */
+export const envVar = {
+    string(options) {
+        return { type: "string", required: false, ...options };
+    },
+    number(options) {
+        return { type: "number", required: false, ...options };
+    },
+    /** `true`/`false`/`1`/`0`/`yes`/`no`. */
+    boolean(options) {
+        return { type: "boolean", required: false, ...options };
+    },
+    /** One of a fixed set — the value is typed as the union, not `string`. */
+    enum(values, options) {
+        return { type: "enum", required: false, values, ...options };
+    },
+    /** A string that must parse as a URL — catches a truncated connection string. */
+    url(options) {
+        return { type: "url", required: false, ...options };
+    },
+};
+/* ------------------------------- validation ------------------------------- */
+/** Thrown when the environment doesn't satisfy the schema. Lists every problem. */
+export class EnvValidationError extends Error {
+    problems;
+    constructor(problems) {
+        super(`The environment is not valid:\n\n${problems.map((p) => `  • ${p}`).join("\n")}\n\n` +
+            `Set these in your .env (or your host's environment) and start again.`);
+        this.problems = problems;
+        this.name = "EnvValidationError";
+    }
+}
+const TRUE = new Set(["true", "1", "yes", "on"]);
+const FALSE = new Set(["false", "0", "no", "off"]);
+/** Coerce one raw string. Returns a problem string instead of throwing. */
+function coerce(name, rule, raw) {
+    switch (rule.type) {
+        case "number": {
+            const value = Number(raw);
+            if (raw.trim() === "" || Number.isNaN(value)) {
+                return { problem: `${name} must be a number, got "${raw}".` };
+            }
+            return { value };
+        }
+        case "boolean": {
+            const lower = raw.toLowerCase();
+            if (TRUE.has(lower))
+                return { value: true };
+            if (FALSE.has(lower))
+                return { value: false };
+            return { problem: `${name} must be true or false, got "${raw}".` };
+        }
+        case "enum": {
+            if (!rule.values?.includes(raw)) {
+                return { problem: `${name} must be one of ${rule.values?.join(", ")}, got "${raw}".` };
+            }
+            return { value: raw };
+        }
+        case "url": {
+            try {
+                new URL(raw);
+            }
+            catch {
+                return { problem: `${name} must be a valid URL, got "${raw}".` };
+            }
+            return { value: raw };
+        }
+        default:
+            return { value: raw };
+    }
+}
+/**
+ * Validate the environment against a schema and return the typed, frozen values.
+ * Throws `EnvValidationError` listing **every** problem if it doesn't hold.
+ *
+ * Call it at module scope in `config/env.ts` so an invalid environment fails the
+ * boot — loudly, immediately, and with the whole list.
+ */
+export function defineEnv(schema, options = {}) {
+    const source = options.source ?? process.env;
+    const values = {};
+    const problems = [];
+    for (const [name, rule] of Object.entries(schema)) {
+        const raw = source[name];
+        // Absent, or set to the empty string — which is almost always a mistake
+        // rather than a deliberate "".
+        if (raw === undefined || raw === "") {
+            if (rule.default !== undefined) {
+                values[name] = rule.default;
+                continue;
+            }
+            if (rule.required) {
+                const hint = rule.description ? ` (${rule.description})` : "";
+                problems.push(`${name} is required but not set${hint}.`);
+                continue;
+            }
+            values[name] = undefined;
+            continue;
+        }
+        const result = coerce(name, rule, raw);
+        if ("problem" in result) {
+            problems.push(result.problem);
+            continue;
+        }
+        const problem = rule.validate?.(result.value);
+        if (problem !== undefined && problem !== true) {
+            problems.push(`${name}: ${problem}`);
+            continue;
+        }
+        values[name] = result.value;
+    }
+    // Every problem at once — fixing a deploy one missing variable per restart is
+    // its own small hell.
+    if (problems.length)
+        throw new EnvValidationError(problems);
+    return Object.freeze(values);
+}

package/dist/core/health.d.ts

@@ -14,8 +14,8 @@
  *   this.use(healthCheck());                    // serves both endpoints
  *
  * Keel ships the checks that mean something wherever it runs — a database, Redis,
- * the cache. Deliberately absent are AdonisJS's disk-space and heap/RSS checks:
- * they measure a Node process, and on Workers there isn't one.
+ * the cache. Deliberately absent are disk-space and heap/RSS checks: they measure
+ * a Node process, and on Workers there isn't one.
  */
 import type { MiddlewareHandler } from "hono";
 export type HealthStatus = "ok" | "warning" | "error";

package/dist/core/health.js

@@ -14,8 +14,8 @@
  *   this.use(healthCheck());                    // serves both endpoints
  *
  * Keel ships the checks that mean something wherever it runs — a database, Redis,
- * the cache. Deliberately absent are AdonisJS's disk-space and heap/RSS checks:
- * they measure a Node process, and on Workers there isn't one.
+ * the cache. Deliberately absent are disk-space and heap/RSS checks: they measure
+ * a Node process, and on Workers there isn't one.
  */
 import { connection } from "./database.js";
 import { redis } from "./redis.js";

package/dist/core/http/kernel.d.ts

@@ -21,6 +21,8 @@ export declare class HttpKernel {
     build(): Hono;
     /** Compile a set of routes onto a fresh Hono instance. */
     private compile;
+    /** Emit `request.handled` with method, path, status, timing, and headers. */
+    private reportRequest;
     private handle;
     /** Default rendering: HTML for browsers, JSON otherwise; details in debug. */
     protected renderException(err: unknown, c: Context): Response;

package/dist/core/http/kernel.js

@@ -8,6 +8,7 @@ import { contextStorage } from "hono/context-storage";
 import { Config } from "../config.js";
 import { HttpException, NotFoundException, ValidationException, STATUS_TEXT, } from "../exceptions.js";
 import { Router } from "./router.js";
+import { instrument, runRequest, newRequestId, currentRequestId } from "../instrumentation.js";
 /** Per-request stash of subdomain params, keyed by the raw Request. */
 const SUBDOMAINS = new WeakMap();
 /** Compile a host pattern like ":tenant.example.com" into a matcher. */
@@ -96,6 +97,26 @@ export class HttpKernel {
                 c.set("subdomains", subs);
             await next();
         });
+        // Open a request scope: a request id everything downstream (queries, logs,
+        // jobs) can attribute itself to, plus timing. Emitting `request.handled` and
+        // `exception` from here — inside the scope — is what lets a watcher tie a
+        // request to everything that happened within it. A no-op stream when nobody
+        // is listening, so this stays cheap for apps that don't instrument.
+        hono.use("*", async (c, next) => {
+            const id = newRequestId();
+            const start = Date.now();
+            try {
+                await runRequest(id, () => next());
+            }
+            catch (err) {
+                // Errors thrown *outside* Hono's per-request handling (rare) land here;
+                // the common case (a handler throwing) is caught by Hono and reaches
+                // `handle()` instead, which is where `exception` is emitted.
+                this.reportRequest(c, id, start, err instanceof HttpException ? err.status : 500);
+                throw err;
+            }
+            this.reportRequest(c, id, start, c.res.status);
+        });
         for (const mw of this.middleware) {
             hono.use("*", mw);
         }
@@ -128,7 +149,34 @@ export class HttpKernel {
         hono.onError((err, c) => this.handle(err, c));
         return hono;
     }
+    /** Emit `request.handled` with method, path, status, timing, and headers. */
+    reportRequest(c, id, start, status) {
+        const url = new URL(c.req.url);
+        const headers = {};
+        c.req.raw.headers.forEach((v, k) => (headers[k] = v));
+        const ip = c.req.header("x-forwarded-for")?.split(",")[0]?.trim();
+        instrument("request.handled", {
+            id,
+            method: c.req.method,
+            path: url.pathname,
+            status,
+            durationMs: Date.now() - start,
+            headers,
+            ...(ip ? { ip } : {}),
+        });
+    }
     async handle(err, c) {
+        // The single choke point every error (thrown handler or unmatched route)
+        // passes through — and it runs inside the request scope, so `currentRequestId`
+        // ties the exception to its request.
+        const requestId = currentRequestId();
+        instrument("exception", {
+            error: err,
+            method: c.req.method,
+            path: new URL(c.req.url).pathname,
+            status: err instanceof HttpException ? err.status : 500,
+            ...(requestId ? { requestId } : {}),
+        });
         // Reportable exceptions: give them a chance to log/report themselves.
         const maybe = err;
         if (typeof maybe?.report === "function") {

package/dist/core/http/router.d.ts

@@ -2,8 +2,8 @@
  * Router facade. Collects route definitions declaratively; the HTTP kernel
  * compiles them onto the underlying Hono instance at boot.
  *
- * Fluent, AdonisJS-inspired API: named routes, per-route and group middleware,
- * prefixes, param constraints, resource routes, and URL generation.
+ * A fluent API: named routes, per-route and group middleware, prefixes, param
+ * constraints, resource routes, and URL generation.
  */
 import type { Context as HonoContext, MiddlewareHandler } from "hono";
 import type { Container, Constructor } from "../container.js";
@@ -66,7 +66,7 @@ export declare class Route {
     as(name: string): this;
     /** Attach middleware that runs only for this route (after group middleware). */
     middleware(mw: MiddlewareRef | MiddlewareRef[]): this;
-    /** Alias for middleware(), matching AdonisJS. */
+    /** Alias for middleware(). */
     use(mw: MiddlewareRef | MiddlewareRef[]): this;
     /** Constrain a route parameter with a regex, source string, or matcher. */
     where(param: string, matcher: Matcher): this;
@@ -81,7 +81,7 @@ export declare class RouteGroup {
     constructor(routes: RouteDefinition[]);
     prefix(prefix: string): this;
     middleware(mw: MiddlewareRef | MiddlewareRef[]): this;
-    /** Alias for middleware(), matching AdonisJS. */
+    /** Alias for middleware(). */
     use(mw: MiddlewareRef | MiddlewareRef[]): this;
     /** Attach metadata to every route in the group (a route's own config wins). */
     config(data: Record<string, unknown>): this;
@@ -115,7 +115,7 @@ declare class RouteMatcher {
     constructor(router: Router, path: string);
     /** Redirect to a path or URL. */
     redirect(to: string, status?: number): Route;
-    /** Alias for redirect(), matching AdonisJS. */
+    /** Alias for redirect(). */
     redirectToPath(to: string, status?: number): Route;
     /** Redirect to a named route, optionally with params and a query string. */
     redirectToRoute(name: string, params?: Record<string, string | number>, options?: {

package/dist/core/http/router.js

@@ -2,8 +2,8 @@
  * Router facade. Collects route definitions declaratively; the HTTP kernel
  * compiles them onto the underlying Hono instance at boot.
  *
- * Fluent, AdonisJS-inspired API: named routes, per-route and group middleware,
- * prefixes, param constraints, resource routes, and URL generation.
+ * A fluent API: named routes, per-route and group middleware, prefixes, param
+ * constraints, resource routes, and URL generation.
  */
 import { view, config } from "../helpers.js";
 import { redirect as makeRedirect, request } from "../request.js";
@@ -56,7 +56,7 @@ export class Route {
         this.def.middleware.push(...(Array.isArray(mw) ? mw : [mw]));
         return this;
     }
-    /** Alias for middleware(), matching AdonisJS. */
+    /** Alias for middleware(). */
     use(mw) {
         return this.middleware(mw);
     }
@@ -94,7 +94,7 @@ export class RouteGroup {
             r.middleware.unshift(...list); // group runs first
         return this;
     }
-    /** Alias for middleware(), matching AdonisJS. */
+    /** Alias for middleware(). */
     use(mw) {
         return this.middleware(mw);
     }
@@ -200,7 +200,7 @@ class RouteMatcher {
     redirect(to, status = 302) {
         return this.router.get(this.path, () => makeRedirect(to, status));
     }
-    /** Alias for redirect(), matching AdonisJS. */
+    /** Alias for redirect(). */
     redirectToPath(to, status = 302) {
         return this.redirect(to, status);
     }