@okay-e9g/hono-config 0.0.36 → 0.0.37

package/package.json

@@ -48,5 +48,5 @@
 		"prepublishOnly": "bun run typecheck && bun test",
 		"typecheck": "tsc --noEmit"
 	},
-	"version": "0.0.36"
+	"version": "0.0.37"
 }

package/src/helpers/factory.openapi.ts

@@ -2,7 +2,7 @@
  * SPDX-License-Identifier: MIT
  */
 
-import { OpenAPIHono } from '@hono/zod-openapi';
+import { OpenAPIHono, type OpenAPIHonoOptions } from '@hono/zod-openapi';
 import type { Factory } from 'hono/factory';
 import type { HonoOptions } from 'hono/hono-base';
 import type { Env } from 'hono/types';
@@ -13,6 +13,26 @@ import { ensureResponseType } from '../middlewares/ensure-rt';
 import { superjson } from '../middlewares/superjson';
 import { type CreateHonoFactoryOpts, createHonoFactory } from './factory';
 
+/**
+ * Options used to customize the shared OpenAPI Hono application factory.
+ *
+ * @typeParam T - Hono environment type for bindings and variables.
+ */
+export interface CreateOpenAPIHonoFactoryOpts<T extends Env> extends CreateHonoFactoryOpts<T> {
+	/**
+	 * Default validation hook used by every app created by this factory.
+	 *
+	 * Receives the validation result and the app's typed Hono context on both
+	 * success and failure. Supports synchronous and asynchronous hooks. Return a
+	 * response to end the request, or throw an error to invoke the app's error
+	 * handler. A hook supplied to `app.openapi` takes precedence for that route.
+	 *
+	 * When omitted or `undefined`, the default hook throws validation errors and
+	 * lets successful validation continue. A custom hook replaces this behavior.
+	 */
+	validationDefaultHook: OpenAPIHonoOptions<T>['defaultHook'];
+}
+
 /**
  * Hono factory whose apps expose OpenAPI route helpers.
  *
@@ -20,7 +40,11 @@ import { type CreateHonoFactoryOpts, createHonoFactory } from './factory';
  */
 export type OpenAPIHonoFactory<T extends Env> = Omit<Factory<T>, 'createApp'> & {
 	/**
-	 * Creates an `OpenAPIHono` app configured with the shared defaults.
+	 * Creates an `OpenAPIHono` app with the factory's middleware, handlers, and
+	 * validation default hook. Routing is always non-strict.
+	 *
+	 * @param opts - Hono application options.
+	 * @returns A new app with OpenAPI route helpers.
 	 */
 	createApp: (opts?: HonoOptions<T>) => OpenAPIHono<T>;
 };
@@ -28,34 +52,39 @@ export type OpenAPIHonoFactory<T extends Env> = Omit<Factory<T>, 'createApp'> &
 /**
  * Creates a Hono factory that produces `OpenAPIHono` apps with shared defaults.
  *
- * The generated apps use non-strict routing, throw validation failures from the
- * OpenAPI default hook, install the shared not-found and error handlers, enable
- * SuperJSON response serialization, apply application middleware when present,
- * and finish with the response-type guard.
+ * The generated apps use non-strict routing, install the configured not-found
+ * and error handlers, enable SuperJSON response serialization, apply application
+ * middleware when present, and finish with the response-type guard.
+ *
+ * By default, OpenAPI validation failures are thrown to the app's error handler.
+ * Set `validationDefaultHook` to replace this behavior for all apps created by
+ * the factory. Individual routes can override it with a hook passed to
+ * `app.openapi`.
  *
  * Include exactly one response-type middleware, such as `apiResponseType()` or
  * `rpcResponseType()`, in `appMiddlewares` so the shared handlers can build the
  * correct response envelope.
  *
  * @typeParam T - Hono environment type for bindings and variables.
- * @param opts - Optional overrides for middleware and default handlers.
+ * @param opts - Optional overrides for middleware, handlers, and the validation default hook.
  * @returns A Hono factory whose `createApp` method returns an `OpenAPIHono`.
  */
 export const createOpenAPIHonoFactory = <T extends Env>({
 	appMiddlewares = [],
 	notFoundHandler = notFound,
 	onErrorHandler = onError,
-}: Partial<CreateHonoFactoryOpts<T>> = {}): OpenAPIHonoFactory<T> => {
+	validationDefaultHook = (result) => {
+		if (!result.success) {
+			throw result.error;
+		}
+	},
+}: Partial<CreateOpenAPIHonoFactoryOpts<T>> = {}): OpenAPIHonoFactory<T> => {
 	return {
 		...createHonoFactory<T>(),
 		createApp: (opts) => {
 			const app = new OpenAPIHono<T>({
 				...(opts as HonoOptions<Env>),
-				defaultHook: (result) => {
-					if (!result.success) {
-						throw result.error;
-					}
-				},
+				defaultHook: validationDefaultHook,
 				strict: false,
 			});