hono 4.13.13 → 5.0.0-rc.0

package/dist/helper/factory/define-handler.js

@@ -0,0 +1,165 @@
+import { HTTPException } from "../../http-exception.js";
+import { getValidationTarget } from "../../validator/validator.js";
+//#region src/helper/factory/define-handler.ts
+const requestTargets = [
+	"param",
+	"query",
+	"header",
+	"cookie",
+	"form",
+	"json"
+];
+const isStandardSchema = (v) => (typeof v === "object" || typeof v === "function") && v !== null && "~standard" in v;
+const toValidationIssues = (issues) => issues.map(({ message, path }) => path ? {
+	message,
+	path: path.map((p) => String(typeof p === "object" ? p.key : p)).join(".")
+} : { message });
+const toValidator = (target, v) => isStandardSchema(v) ? {
+	target,
+	schema: v["~standard"].validate
+} : {
+	target,
+	fn: v
+};
+const toResponse = (c, result) => {
+	if (result instanceof Response) return result;
+	if (result === null || result === void 0) return c.body(null, 204);
+	return typeof result === "string" || result.isEscaped ? c.html(result) : c.json(result);
+};
+/**
+* `defineHandler()` defines a handler. A value returned from the handler is converted to a
+* Response: an object is returned as JSON, a string or JSX as HTML, and `null` or `undefined`
+* as `204 No Content`. A `Response` is returned as is. The status is set with `c.status()`, and
+* it is not in the types. Return `c.json()` to have the status in the types.
+*
+* With options, each request target (`param`, `query`, `json`, `form`, `header`, `cookie`)
+* is validated before the handler runs. The validated values are passed to the handler as
+* the second argument, and are also available through `c.req.valid()`.
+* A value returned from the handler is validated with `response` and returned as JSON.
+*
+* Each validation accepts a Standard Schema or a validation function.
+* When a Standard Schema fails, an `HTTPException` is thrown with status 400 for the request
+* and 500 for the response, so `onError` can handle it. Its `res` is a JSON response of
+* `{ error, issues }`, and its `cause` is `{ issues }` with the raw Standard Schema issues.
+*
+* Middleware passed before the handler runs first, around the validation. Its Env flows into
+* the handler, so `c.get()` is typed. Otherwise, use `createFactory<Env>().defineHandler`, or
+* pass the Env and the path as type arguments.
+*
+* @see {@link https://hono.dev/docs/helpers/factory#definehandler}
+*
+* @experimental
+* `defineHandler()` is an experimental feature.
+* The API might be changed.
+*
+* @example
+* ```ts
+* app.get('/ping', defineHandler(() => ({ pong: true })))
+* app.get('/me', defineHandler(auth, (c) => c.get('user')))
+*
+* app.post(
+*   '/users/:id',
+*   defineHandler({
+*     param: ParamSchema,
+*     json: BodySchema,
+*     response: UserSchema,
+*   })(async (c, { param, json }) => {
+*     c.status(201)
+*     return { id: param.id, ...json }
+*   })
+* )
+* ```
+*/
+const defineHandler = ((...args) => {
+	if (typeof args[0] === "function") return compose(args, async (c) => toResponse(c, await args[args.length - 1](c)));
+	const options = args[0];
+	const validators = requestTargets.filter((target) => options[target]).map((target) => toValidator(target, options[target]));
+	const response = options.response && toValidator("json", options.response);
+	return (...args) => {
+		const handler = args[args.length - 1];
+		const run = async (c) => {
+			const input = {};
+			const failures = [];
+			const issues = [];
+			for (const { target, schema, fn } of validators) {
+				let value = getValidationTarget(c, target);
+				if (value instanceof Promise) value = await value;
+				if (schema) {
+					let result = schema(value);
+					if (result instanceof Promise) result = await result;
+					if (result.issues) {
+						failures.push({
+							slot: target,
+							issues: toValidationIssues(result.issues)
+						});
+						issues.push({
+							slot: target,
+							issues: result.issues
+						});
+						continue;
+					}
+					value = result.value;
+				} else {
+					value = fn(value, c);
+					if (value instanceof Promise) value = await value;
+					if (value instanceof Response) return value;
+				}
+				c.req.addValidatedData(target, value);
+				input[target] = value;
+			}
+			if (failures.length) throw new HTTPException(400, {
+				res: c.json({
+					error: "Validation failed",
+					issues: failures
+				}, 400),
+				cause: { issues }
+			});
+			let result = handler(c, input);
+			if (result instanceof Promise) result = await result;
+			if (result instanceof Response) return result;
+			if (response) {
+				if (response.schema) {
+					let validated = response.schema(result);
+					if (validated instanceof Promise) validated = await validated;
+					if (validated.issues) throw new HTTPException(500, {
+						res: c.json({ error: "Response validation failed" }, 500),
+						cause: { issues: [{
+							slot: "response",
+							issues: validated.issues
+						}] }
+					});
+					result = validated.value;
+				} else {
+					result = response.fn(result, c);
+					if (result instanceof Promise) result = await result;
+					if (result instanceof Response) return result;
+				}
+				return c.json(result);
+			}
+			return toResponse(c, result);
+		};
+		return Object.assign(compose(args, run), { validations: options });
+	};
+});
+/**
+* Runs the middleware (all but the last argument) around `run`,
+* so code after `await next()` runs after the handler.
+*/
+const compose = (args, run) => {
+	const middleware = args.slice(0, -1);
+	if (!middleware.length) return run;
+	return async (c) => {
+		const dispatch = async (i) => {
+			if (i === middleware.length) {
+				c.res = await run(c);
+				return;
+			}
+			const res = await middleware[i](c, () => dispatch(i + 1));
+			if (res) c.res = res;
+		};
+		await dispatch(0);
+		return c.res;
+	};
+};
+//#endregion
+export { defineHandler };

package/dist/{types/helper → helper}/factory/index.d.ts

@@ -1,6 +1,7 @@
-import { HonoOptions } from "../../hono-base.js";
 import { Env, H, HandlerResponse, Input, IntersectNonAnyTypes, MiddlewareHandler } from "../../types.js";
+import { HonoOptions } from "../../hono-base.js";
 import { Hono } from "../../hono.js";
+import { DefineHandler, StandardSchema, ValidationFailure, ValidationIssue, defineHandler } from "./define-handler.js";
 //#region src/helper/factory/index.d.ts
 type InitApp<E extends Env = Env> = (app: Hono<E>) => void;
 export interface CreateHandlersInterface<E extends Env, P extends string> {
@@ -23,13 +24,41 @@ export declare class Factory<E extends Env = Env, P extends string = string> {
     defaultAppOptions?: HonoOptions<E>;
   });
   createApp: (options?: HonoOptions<E>) => Hono<E>;
+  defineMiddleware: <I extends Input = {}, R extends HandlerResponse<any> | void = void>(middleware: MiddlewareHandler<E, P, I, R extends void ? Response : R>) => MiddlewareHandler<E, P, I, R extends void ? Response : R>;
+  defineHandler: DefineHandler<E, P>;
+  /**
+   * @deprecated Use `defineMiddleware()` instead. It will be removed in the next major version.
+   */
   createMiddleware: <I extends Input = {}, R extends HandlerResponse<any> | void = void>(middleware: MiddlewareHandler<E, P, I, R extends void ? Response : R>) => MiddlewareHandler<E, P, I, R extends void ? Response : R>;
+  /**
+   * @deprecated Use `defineHandler()` instead. It will be removed in the next major version.
+   * Pass the middleware before the handler:
+   * `defineHandler(auth, (c) => ...)`.
+   */
   createHandlers: CreateHandlersInterface<E, P>;
 }
 export declare const createFactory: <E extends Env = Env, P extends string = string>(init?: {
   initApp?: InitApp<E>;
   defaultAppOptions?: HonoOptions<E>;
 }) => Factory<E, P>;
+/**
+ * `defineMiddleware()` defines a middleware with the types.
+ *
+ * @see {@link https://hono.dev/docs/helpers/factory#definemiddleware}
+ *
+ * @example
+ * ```ts
+ * const auth = defineMiddleware<{ Variables: { user: User } }>(async (c, next) => {
+ *   c.set('user', await getUser(c))
+ *   await next()
+ * })
+ * ```
+ */
+export declare const defineMiddleware: <E extends Env = any, P extends string = string, I extends Input = {}, R extends HandlerResponse<any> | void = void>(middleware: MiddlewareHandler<E, P, I, R extends void ? Response : R>) => MiddlewareHandler<E, P, I, R extends void ? Response : R>;
+/**
+ * @deprecated Use `defineMiddleware()` instead. It will be removed in the next major version.
+ */
 export declare const createMiddleware: <E extends Env = any, P extends string = string, I extends Input = {}, R extends HandlerResponse<any> | void = void>(middleware: MiddlewareHandler<E, P, I, R extends void ? Response : R>) => MiddlewareHandler<E, P, I, R extends void ? Response : R>;
 //#endregion
+export { type StandardSchema, type ValidationFailure, type ValidationIssue, defineHandler };
 export {};

package/dist/helper/factory/index.js

@@ -1,4 +1,5 @@
 import { Hono } from "../../hono.js";
+import { defineHandler } from "./define-handler.js";
 //#region src/helper/factory/index.ts
 /**
 * @module
@@ -19,12 +20,39 @@ var Factory = class {
 		if (this.initApp) this.initApp(app);
 		return app;
 	};
-	createMiddleware = (middleware) => middleware;
+	defineMiddleware = (middleware) => middleware;
+	defineHandler = defineHandler;
+	/**
+	* @deprecated Use `defineMiddleware()` instead. It will be removed in the next major version.
+	*/
+	createMiddleware = this.defineMiddleware;
+	/**
+	* @deprecated Use `defineHandler()` instead. It will be removed in the next major version.
+	* Pass the middleware before the handler:
+	* `defineHandler(auth, (c) => ...)`.
+	*/
 	createHandlers = (...handlers) => {
 		return handlers.filter((handler) => handler !== void 0);
 	};
 };
 const createFactory = (init) => new Factory(init);
-const createMiddleware = (middleware) => middleware;
+/**
+* `defineMiddleware()` defines a middleware with the types.
+*
+* @see {@link https://hono.dev/docs/helpers/factory#definemiddleware}
+*
+* @example
+* ```ts
+* const auth = defineMiddleware<{ Variables: { user: User } }>(async (c, next) => {
+*   c.set('user', await getUser(c))
+*   await next()
+* })
+* ```
+*/
+const defineMiddleware = (middleware) => middleware;
+/**
+* @deprecated Use `defineMiddleware()` instead. It will be removed in the next major version.
+*/
+const createMiddleware = defineMiddleware;
 //#endregion
-export { Factory, createFactory, createMiddleware };
+export { Factory, createFactory, createMiddleware, defineHandler, defineMiddleware };

package/dist/{types/helper → helper}/ssg/middleware.d.ts

@@ -3,12 +3,6 @@ import { Context } from "../../context.js";
 //#region src/helper/ssg/middleware.d.ts
 export declare const SSG_CONTEXT = "HONO_SSG_CONTEXT";
 export declare const X_HONO_DISABLE_SSG_HEADER_KEY = "x-hono-disable-ssg";
-/**
- * @deprecated
- * Use `X_HONO_DISABLE_SSG_HEADER_KEY` instead.
- * This constant will be removed in the next minor version.
- */
-export declare const SSG_DISABLED_RESPONSE: Response;
 interface SSGParam {
   [key: string]: string;
 }

package/dist/helper/ssg/middleware.js

@@ -3,21 +3,6 @@ import { isDynamicRoute } from "./utils.js";
 const SSG_CONTEXT = "HONO_SSG_CONTEXT";
 const X_HONO_DISABLE_SSG_HEADER_KEY = "x-hono-disable-ssg";
 /**
-* @deprecated
-* Use `X_HONO_DISABLE_SSG_HEADER_KEY` instead.
-* This constant will be removed in the next minor version.
-*/
-const SSG_DISABLED_RESPONSE = (() => {
-	try {
-		return new Response("SSG is disabled", {
-			status: 404,
-			headers: { [X_HONO_DISABLE_SSG_HEADER_KEY]: "true" }
-		});
-	} catch {
-		return null;
-	}
-})();
-/**
 * Define SSG Route
 */
 const ssgParams = (params) => async (c, next) => {
@@ -55,4 +40,4 @@ const onlySSG = () => async function onlySSG(c, next) {
 	await next();
 };
 //#endregion
-export { SSG_CONTEXT, SSG_DISABLED_RESPONSE, X_HONO_DISABLE_SSG_HEADER_KEY, disableSSG, isSSGContext, onlySSG, ssgParams };
+export { SSG_CONTEXT, X_HONO_DISABLE_SSG_HEADER_KEY, disableSSG, isSSGContext, onlySSG, ssgParams };

package/dist/{types/helper → helper}/ssg/ssg.d.ts

@@ -37,18 +37,6 @@ export interface SSGPlugin {
 }
 export interface ToSSGOptions {
   dir?: string;
-  /**
-   * @deprecated Use plugins[].beforeRequestHook instead.
-   */
-  beforeRequestHook?: BeforeRequestHook | BeforeRequestHook[];
-  /**
-   * @deprecated Use plugins[].afterResponseHook instead.
-   */
-  afterResponseHook?: AfterResponseHook | AfterResponseHook[];
-  /**
-   * @deprecated Use plugins[].afterGenerateHook instead.
-   */
-  afterGenerateHook?: AfterGenerateHook | AfterGenerateHook[];
   concurrency?: number;
   extensionMap?: Record<string, string>;
   plugins?: SSGPlugin[];

package/dist/helper/ssg/ssg.js

@@ -169,9 +169,6 @@ const toSSG = async (app, fs, options) => {
 	const beforeRequestHooks = [];
 	const afterResponseHooks = [];
 	const afterGenerateHooks = [];
-	if (options?.beforeRequestHook) beforeRequestHooks.push(...Array.isArray(options.beforeRequestHook) ? options.beforeRequestHook : [options.beforeRequestHook]);
-	if (options?.afterResponseHook) afterResponseHooks.push(...Array.isArray(options.afterResponseHook) ? options.afterResponseHook : [options.afterResponseHook]);
-	if (options?.afterGenerateHook) afterGenerateHooks.push(...Array.isArray(options.afterGenerateHook) ? options.afterGenerateHook : [options.afterGenerateHook]);
 	for (const plugin of plugins) {
 		if (plugin.beforeRequestHook) beforeRequestHooks.push(...Array.isArray(plugin.beforeRequestHook) ? plugin.beforeRequestHook : [plugin.beforeRequestHook]);
 		if (plugin.afterResponseHook) afterResponseHooks.push(...Array.isArray(plugin.afterResponseHook) ? plugin.afterResponseHook : [plugin.afterResponseHook]);

package/dist/{types/hono-base.d.ts → hono-base.d.ts}

@@ -1,6 +1,6 @@
 import { Router } from "./router.js";
 import { Env, ErrorHandler, H, HandlerInterface, MergePath, MergeSchemaPath, MiddlewareHandlerInterface, NotFoundHandler, OnHandlerInterface, RouterRoute, Schema } from "./types.js";
-import { Context, ExecutionContext } from "./context.js";
+import { ExecutionContext } from "./context.js";
 //#region src/hono-base.d.ts
 type GetPath<E extends Env> = (request: Request, options?: {
   env?: E['Bindings'];
@@ -47,12 +47,6 @@ export type HonoOptions<E extends Env> = {
    */
   getPath?: GetPath<E>;
 };
-type MountOptionHandler = (c: Context) => unknown;
-type MountReplaceRequest = (originalRequest: Request) => Request;
-type MountOptions = MountOptionHandler | {
-  optionHandler?: MountOptionHandler;
-  replaceRequest?: MountReplaceRequest | false;
-};
 declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/', CurrentPath extends string = BasePath> {
   
   get: HandlerInterface<E, 'get', S, BasePath, CurrentPath>;
@@ -106,6 +100,8 @@ declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends
   basePath<SubPath extends string>(path: SubPath): Hono<E, S, MergePath<BasePath, SubPath>, MergePath<BasePath, SubPath>>;
   /**
    * `.onError()` handles an error and returns a customized Response.
+   * Non-Error values thrown by handlers are wrapped in an Error with the original value as its cause.
+   * If the thrown value is a string, it is also used as the error message.
    *
    * @see {@link https://hono.dev/docs/api/hono#error-handling}
    *
@@ -137,41 +133,6 @@ declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends
    * ```
    */
   notFound: (handler: NotFoundHandler<E>) => Hono<E, S, BasePath, CurrentPath>;
-  /**
-   * `.mount()` allows you to mount applications built with other frameworks into your Hono application.
-   *
-   * @deprecated Use `mount()` from `hono/mount` instead. `.mount()` will be removed in v5.
-   *
-   * @see {@link https://hono.dev/docs/api/hono#mount}
-   *
-   * @param {string} path - base Path
-   * @param {Function} applicationHandler - other Request Handler
-   * @param {MountOptions} [options] - options of `.mount()`
-   * @returns {Hono} mounted Hono instance
-   *
-   * @example
-   * ```ts
-   * import { Router as IttyRouter } from 'itty-router'
-   * import { Hono } from 'hono'
-   * // Create itty-router application
-   * const ittyRouter = IttyRouter()
-   * // GET /itty-router/hello
-   * ittyRouter.get('/hello', () => new Response('Hello from itty-router'))
-   *
-   * const app = new Hono()
-   * app.mount('/itty-router', ittyRouter.handle)
-   * ```
-   *
-   * @example
-   * ```ts
-   * const app = new Hono()
-   * // Send the request to another application without modification.
-   * app.mount('/app', anotherApp, {
-   *   replaceRequest: (req) => req,
-   * })
-   * ```
-   */
-  mount(path: string, applicationHandler: (request: Request, ...args: any) => Response | Promise<Response>, options?: MountOptions): Hono<E, S, BasePath, CurrentPath>;
   /**
    * `.fetch()` will be entry point of your app.
    *
@@ -197,24 +158,6 @@ declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends
    * @see https://hono.dev/docs/api/hono#request
    */
   request: (input: Request | string | URL, requestInit?: RequestInit, Env?: E["Bindings"] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
-  /**
-   * `.fire()` automatically adds a global fetch event listener.
-   * This can be useful for environments that adhere to the Service Worker API, such as non-ES module Cloudflare Workers.
-   * @deprecated
-   * Use `fire` from `hono/service-worker` instead.
-   * ```ts
-   * import { Hono } from 'hono'
-   * import { fire } from 'hono/service-worker'
-   *
-   * const app = new Hono()
-   * // ...
-   * fire(app)
-   * ```
-   * @see https://hono.dev/docs/api/hono#fire
-   * @see https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API
-   * @see https://developers.cloudflare.com/workers/reference/migrate-to-module-workers/
-   */
-  fire: () => void;
 }
 //#endregion
 export { Hono as HonoBase };

package/dist/hono-base.js

@@ -1,4 +1,4 @@
-import { compose } from "./compose.js";
+import { compose, toError } from "./compose.js";
 import { getPath, getPathNoStrict, mergePath } from "./utils/url.js";
 import { Context } from "./context.js";
 import { METHODS } from "./router.js";
@@ -135,6 +135,8 @@ var Hono = class Hono {
 	}
 	/**
 	* `.onError()` handles an error and returns a customized Response.
+	* Non-Error values thrown by handlers are wrapped in an Error with the original value as its cause.
+	* If the thrown value is a string, it is also used as the error message.
 	*
 	* @see {@link https://hono.dev/docs/api/hono#error-handling}
 	*
@@ -172,78 +174,6 @@ var Hono = class Hono {
 		this.#notFoundHandler = handler;
 		return this;
 	};
-	/**
-	* `.mount()` allows you to mount applications built with other frameworks into your Hono application.
-	*
-	* @deprecated Use `mount()` from `hono/mount` instead. `.mount()` will be removed in v5.
-	*
-	* @see {@link https://hono.dev/docs/api/hono#mount}
-	*
-	* @param {string} path - base Path
-	* @param {Function} applicationHandler - other Request Handler
-	* @param {MountOptions} [options] - options of `.mount()`
-	* @returns {Hono} mounted Hono instance
-	*
-	* @example
-	* ```ts
-	* import { Router as IttyRouter } from 'itty-router'
-	* import { Hono } from 'hono'
-	* // Create itty-router application
-	* const ittyRouter = IttyRouter()
-	* // GET /itty-router/hello
-	* ittyRouter.get('/hello', () => new Response('Hello from itty-router'))
-	*
-	* const app = new Hono()
-	* app.mount('/itty-router', ittyRouter.handle)
-	* ```
-	*
-	* @example
-	* ```ts
-	* const app = new Hono()
-	* // Send the request to another application without modification.
-	* app.mount('/app', anotherApp, {
-	*   replaceRequest: (req) => req,
-	* })
-	* ```
-	*/
-	mount(path, applicationHandler, options) {
-		let replaceRequest;
-		let optionHandler;
-		if (options) {
-			if (typeof options === "function") optionHandler = options;
-			else {
-				optionHandler = options.optionHandler;
-				if (options.replaceRequest === false) replaceRequest = (request) => request;
-				else replaceRequest = options.replaceRequest;
-			}
-		}
-		const getOptions = optionHandler ? (c) => {
-			const options = optionHandler(c);
-			return Array.isArray(options) ? options : [options];
-		} : (c) => {
-			let executionContext = void 0;
-			try {
-				executionContext = c.executionCtx;
-			} catch {}
-			return [c.env, executionContext];
-		};
-		replaceRequest ||= (() => {
-			const mergedPath = mergePath(this._basePath, path);
-			const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
-			return (request) => {
-				const url = new URL(request.url);
-				url.pathname = this.getPath(request).slice(pathPrefixLength) || "/";
-				return new Request(url, request);
-			};
-		})();
-		const handler = async (c, next) => {
-			const res = await applicationHandler(replaceRequest(c.req.raw), ...getOptions(c));
-			if (res) return res;
-			await next();
-		};
-		this.#addRoute("ALL", mergePath(path, "*"), handler);
-		return this;
-	}
 	#addRoute(method, path, handler, baseRoutePath) {
 		path = mergePath(this._basePath, path);
 		const r = {
@@ -256,8 +186,9 @@ var Hono = class Hono {
 		this.routes.push(r);
 	}
 	#handleError(err, c) {
-		if (err instanceof Error) return this.errorHandler(err, c);
-		throw err;
+		const error = toError(err);
+		c.error = error;
+		return this.errorHandler(error, c);
 	}
 	#dispatch(request, executionCtx, env, method) {
 		if (method === "HEAD") return (async () => new Response(null, await this.#dispatch(request, executionCtx, env, "GET")))();
@@ -323,28 +254,6 @@ var Hono = class Hono {
 		input = input.toString();
 		return this.fetch(new Request(/^https?:\/\//.test(input) ? input : `http://localhost${mergePath("/", input)}`, requestInit), Env, executionCtx);
 	};
-	/**
-	* `.fire()` automatically adds a global fetch event listener.
-	* This can be useful for environments that adhere to the Service Worker API, such as non-ES module Cloudflare Workers.
-	* @deprecated
-	* Use `fire` from `hono/service-worker` instead.
-	* ```ts
-	* import { Hono } from 'hono'
-	* import { fire } from 'hono/service-worker'
-	*
-	* const app = new Hono()
-	* // ...
-	* fire(app)
-	* ```
-	* @see https://hono.dev/docs/api/hono#fire
-	* @see https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API
-	* @see https://developers.cloudflare.com/workers/reference/migrate-to-module-workers/
-	*/
-	fire = () => {
-		addEventListener("fetch", (event) => {
-			event.respondWith(this.#dispatch(event.request, event, void 0, event.request.method));
-		});
-	};
 };
 //#endregion
 export { Hono as HonoBase };

package/dist/{types/hono.d.ts → hono.d.ts}

@@ -1,5 +1,5 @@
-import { HonoBase as Hono$1, HonoOptions } from "./hono-base.js";
 import { BlankEnv, BlankSchema, Env, Schema } from "./types.js";
+import { HonoBase as Hono$1, HonoOptions } from "./hono-base.js";
 //#region src/hono.d.ts
 /**
  * The Hono class extends the functionality of the HonoBase class.

package/dist/{types/middleware → middleware}/basic-auth/index.d.ts

@@ -1,18 +1,19 @@
 import { MiddlewareHandler } from "../../types.js";
 import { Context } from "../../context.js";
+import { StringHashFunction } from "../../utils/buffer.js";
 //#region src/middleware/basic-auth/index.d.ts
 type MessageFunction = (c: Context) => string | object | Promise<string | object>;
 type BasicAuthOptions = {
   username: string;
   password: string;
   realm?: string;
-  hashFunction?: Function;
+  hashFunction?: StringHashFunction;
   invalidUserMessage?: string | object | MessageFunction;
   onAuthSuccess?: (c: Context, username: string) => void | Promise<void>;
 } | {
   verifyUser: (username: string, password: string, c: Context) => boolean | Promise<boolean>;
   realm?: string;
-  hashFunction?: Function;
+  hashFunction?: StringHashFunction;
   invalidUserMessage?: string | object | MessageFunction;
   onAuthSuccess?: (c: Context, username: string) => void | Promise<void>;
 };
@@ -25,7 +26,7 @@ type BasicAuthOptions = {
  * @param {string} options.username - The username for authentication.
  * @param {string} options.password - The password for authentication.
  * @param {string} [options.realm="Secure Area"] - The realm attribute for the WWW-Authenticate header.
- * @param {Function} [options.hashFunction] - The hash function used for secure comparison.
+ * @param {StringHashFunction} [options.hashFunction] - The hash function used for secure comparison.
  * @param {Function} [options.verifyUser] - The function to verify user credentials.
  * @param {string | object | MessageFunction} [options.invalidUserMessage="Unauthorized"] - The invalid user message.
  * @param {Function} [options.onAuthSuccess] - Callback function called on successful authentication.

package/dist/middleware/basic-auth/index.js

@@ -11,7 +11,7 @@ import { auth } from "../../utils/basic-auth.js";
 * @param {string} options.username - The username for authentication.
 * @param {string} options.password - The password for authentication.
 * @param {string} [options.realm="Secure Area"] - The realm attribute for the WWW-Authenticate header.
-* @param {Function} [options.hashFunction] - The hash function used for secure comparison.
+* @param {StringHashFunction} [options.hashFunction] - The hash function used for secure comparison.
 * @param {Function} [options.verifyUser] - The function to verify user credentials.
 * @param {string | object | MessageFunction} [options.invalidUserMessage="Unauthorized"] - The invalid user message.
 * @param {Function} [options.onAuthSuccess] - Callback function called on successful authentication.

package/dist/{types/middleware → middleware}/bearer-auth/index.d.ts

@@ -1,5 +1,6 @@
 import { Env, MiddlewareHandler } from "../../types.js";
 import { Context } from "../../context.js";
+import { StringHashFunction } from "../../utils/buffer.js";
 //#region src/middleware/bearer-auth/index.d.ts
 type MessageFunction = (c: Context) => string | object | Promise<string | object>;
 type CustomizedErrorResponseOptions = {
@@ -11,42 +12,18 @@ type BearerAuthOptions<E extends Env = Env> = {
   realm?: string;
   prefix?: string;
   headerName?: string;
-  hashFunction?: Function;
-  /**
-   * @deprecated Use noAuthenticationHeader.message instead
-   */
-  noAuthenticationHeaderMessage?: string | object | MessageFunction;
+  hashFunction?: StringHashFunction;
   noAuthenticationHeader?: CustomizedErrorResponseOptions;
-  /**
-   * @deprecated Use invalidAuthenticationHeader.message instead
-   */
-  invalidAuthenticationHeaderMessage?: string | object | MessageFunction;
   invalidAuthenticationHeader?: CustomizedErrorResponseOptions;
-  /**
-   * @deprecated Use invalidToken.message instead
-   */
-  invalidTokenMessage?: string | object | MessageFunction;
   invalidToken?: CustomizedErrorResponseOptions;
 } | {
   realm?: string;
   prefix?: string;
   headerName?: string;
   verifyToken: (token: string, c: Context<E>) => boolean | Promise<boolean>;
-  hashFunction?: Function;
-  /**
-   * @deprecated Use noAuthenticationHeader.message instead
-   */
-  noAuthenticationHeaderMessage?: string | object | MessageFunction;
+  hashFunction?: StringHashFunction;
   noAuthenticationHeader?: CustomizedErrorResponseOptions;
-  /**
-   * @deprecated Use invalidAuthenticationHeader.message instead
-   */
-  invalidAuthenticationHeaderMessage?: string | object | MessageFunction;
   invalidAuthenticationHeader?: CustomizedErrorResponseOptions;
-  /**
-   * @deprecated Use invalidToken.message instead
-   */
-  invalidTokenMessage?: string | object | MessageFunction;
   invalidToken?: CustomizedErrorResponseOptions;
 };
 /**
@@ -61,7 +38,7 @@ type BearerAuthOptions<E extends Env = Env> = {
  * @param {string} [options.realm=""] - The domain name of the realm, as part of the returned WWW-Authenticate challenge header.
  * @param {string} [options.prefix="Bearer"] - The prefix (or known as `schema`) for the Authorization header value. If set to the empty string, no prefix is expected.
  * @param {string} [options.headerName=Authorization] - The header name.
- * @param {Function} [options.hashFunction] - A function to handle hashing for safe comparison of authentication tokens.
+ * @param {StringHashFunction} [options.hashFunction] - A function to handle hashing for safe comparison of authentication tokens.
  * @param {string | object | MessageFunction} [options.noAuthenticationHeader.message="Unauthorized"] - The no authentication header message.
  * @param {string | object | MessageFunction} [options.noAuthenticationHeader.wwwAuthenticateHeader="Bearer realm=\"\""] - The response header value for the WWW-Authenticate header when no authentication header is provided.
  * @param {string | object | MessageFunction} [options.invalidAuthenticationHeader.message="Bad Request"] - The invalid authentication header message.