@okay-e9g/hono-config 0.0.2 → 0.0.4

package/package.json

@@ -37,5 +37,5 @@
 		"prepublishOnly": "bun run typecheck && bun test",
 		"typecheck": "tsc --noEmit"
 	},
-	"version": "0.0.2"
+	"version": "0.0.4"
 }

package/src/handlers/not-found.ts

@@ -10,11 +10,17 @@ import { statusText } from '../schemas';
 /**
  * Creates the shared 404 handler used by the configured Hono factories.
  *
+ * Falls back to a plain text 404 when no response helper has been installed.
+ *
  * @internal
  */
 export const notFound = <T extends Env>(): NotFoundHandler<T> => {
 	return (c) => {
-		const { response } = c.var as ResponseEnv['Variables'];
+		const { response } = c.var as Partial<ResponseEnv['Variables']>;
+
+		if (response === undefined) {
+			return c.text(statusText[404], 404);
+		}
 
 		if (response.type === 'api') {
 			return c.json(response.error(404), 404);

package/src/handlers/on-error.ts

@@ -7,16 +7,32 @@ import type { Env, ErrorHandler } from 'hono/types';
 import { z } from 'zod';
 
 import type { ResponseEnv } from '../middlewares/ensure-rt';
-import { type ClientErrorStatusCode, type ServerErrorStatusCode, type StatusCode, statusText } from '../schemas';
+import { type ClientErrorStatusCode, type ServerErrorStatusCode, statusText } from '../schemas';
+
+interface TypedHTTPException extends Omit<HTTPException, 'status'> {
+	status: ClientErrorStatusCode & ServerErrorStatusCode;
+}
+
+const assertHTTPException = (err: Error): err is TypedHTTPException => {
+	return err instanceof HTTPException || (err instanceof Error && 'getResponse' in err && 'status' in err);
+};
 
 /**
  * Creates the shared error handler used by the configured Hono factories.
  *
+ * Errors are rethrown when no response helper has been installed, allowing
+ * Hono's fallback error handling to handle apps that are not using this
+ * package's response envelopes.
+ *
  * @internal
  */
 export const onError = <T extends Env>(): ErrorHandler<T> => {
 	return (err, c) => {
-		const { response } = c.var as ResponseEnv['Variables'];
+		const { response } = c.var as Partial<ResponseEnv['Variables']>;
+
+		if (response === undefined) {
+			throw err;
+		}
 
 		if (err instanceof z.ZodError) {
 			if (response.type === 'api') {
@@ -26,14 +42,14 @@ export const onError = <T extends Env>(): ErrorHandler<T> => {
 			return c.json(response.error(z.flattenError(err)));
 		}
 
-		if (err instanceof HTTPException) {
+		if (assertHTTPException(err)) {
 			const { message, status } = err;
 
 			if (response.type === 'api') {
-				return c.json(response.error(status as ClientErrorStatusCode | ServerErrorStatusCode, message), status);
+				return c.json(response.error(status, message), status);
 			}
 
-			return c.json(response.error(message === '' ? statusText[status as StatusCode] : message));
+			return c.json(response.error(message === '' ? statusText[status] : message));
 		}
 
 		const errMessage = err instanceof Error ? err.message : err;

package/src/helpers/factory.openapi.ts

@@ -30,7 +30,7 @@ export type OpenAPIHonoFactory<T extends Env> = Omit<Factory<T>, 'createApp'> &
  *
  * 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 any provided application middleware,
+ * SuperJSON response serialization, apply application middleware when present,
  * and finish with the response-type guard.
  *
  * Include exactly one response-type middleware, such as `apiResponseType()` or
@@ -61,9 +61,12 @@ export const createOpenAPIHonoFactory = <T extends Env>({
 
 			app.notFound(notFoundHandler());
 			app.onError(onErrorHandler());
-
 			app.use(superjson());
-			app.use(...appMiddlewares);
+
+			if (appMiddlewares.length) {
+				app.use(...appMiddlewares);
+			}
+
 			app.use(ensureResponseType());
 
 			return app;

package/src/helpers/factory.ts

@@ -36,8 +36,8 @@ export type CreateHonoFactoryOpts<T extends Env> = {
  *
  * The generated apps use non-strict routing, the shared not-found and error
  * handlers, SuperJSON response serialization, any provided application
- * middleware, and the response-type guard used by `apiResponseType` and
- * `rpcResponseType`.
+ * middleware when present, and the response-type guard used by
+ * `apiResponseType` and `rpcResponseType`.
  *
  * Include exactly one response-type middleware, such as `apiResponseType()` or
  * `rpcResponseType()`, in `appMiddlewares` so the shared handlers can build the
@@ -59,9 +59,12 @@ export const createHonoFactory = <T extends Env>({
 		initApp: (app) => {
 			app.notFound(notFoundHandler());
 			app.onError(onErrorHandler());
-
 			app.use(superjson());
-			app.use(...appMiddlewares);
+
+			if (appMiddlewares.length) {
+				app.use(...appMiddlewares);
+			}
+
 			app.use(ensureResponseType());
 		},
 	});

package/src/middlewares/response.ts

@@ -33,12 +33,6 @@ type ErrorStatusCode = ClientErrorStatusCode | ServerErrorStatusCode;
 
 type ResultStatusCode = Exclude<SuccessStatusCode, 204 | 205>;
 
-const assertResponseTypeNotInitialized = (response: unknown): void => {
-	if (response !== undefined) {
-		throw new Error('Response type middleware already initialized.');
-	}
-};
-
 /**
  * Hono environment contract added by `apiResponseType`.
  */
@@ -71,29 +65,31 @@ export interface ApiResponseEnv extends Env {
  * Installs `c.var.response` helpers for conventional HTTP API responses.
  *
  * The helpers produce `{ success: false, error }` and `{ success: true, result }`
- * envelopes validated by the exported API schemas.
+ * envelopes validated by the exported API schemas. If another response helper is
+ * already installed, the existing helper is kept so applications can compose
+ * middleware safely.
  *
  * @returns Hono middleware that adds the API response helper contract.
  */
 export const apiResponseType = (): MiddlewareHandler<ApiResponseEnv> => {
 	return createMiddleware(async (c, next) => {
-		assertResponseTypeNotInitialized(c.var.response);
-
-		c.set('response', {
-			error: <T, U extends ErrorStatusCode>(status: U, error?: T) => {
-				return apiError.parse({
-					error: error === undefined || error === '' ? statusText[status] : error,
-					success: false,
-				}) as TypedApiError<T>;
-			},
-			result: <T, U extends ResultStatusCode>(status: U, result?: T) => {
-				return apiResult.parse({
-					result: result === undefined || result === '' ? statusText[status] : result,
-					success: true,
-				}) as TypedApiResult<T>;
-			},
-			type: 'api',
-		});
+		if (c.var.response === undefined) {
+			c.set('response', {
+				error: <T, U extends ErrorStatusCode>(status: U, error?: T) => {
+					return apiError.parse({
+						error: error === undefined || error === '' ? statusText[status] : error,
+						success: false,
+					}) as TypedApiError<T>;
+				},
+				result: <T, U extends ResultStatusCode>(status: U, result?: T) => {
+					return apiResult.parse({
+						result: result === undefined || result === '' ? statusText[status] : result,
+						success: true,
+					}) as TypedApiResult<T>;
+				},
+				type: 'api',
+			});
+		}
 
 		await next();
 	});
@@ -136,23 +132,25 @@ export interface RpcResponseEnv extends Env {
  * Installs `c.var.response` helpers for JSON-RPC 2.0 responses.
  *
  * The helpers produce `error` and `result` envelopes validated by the exported
- * JSON-RPC schemas and default missing ids to the schema default.
+ * JSON-RPC schemas and default missing ids to the schema default. If another
+ * response helper is already installed, the existing helper is kept so
+ * applications can compose middleware safely.
  *
  * @returns Hono middleware that adds the RPC response helper contract.
  */
 export const rpcResponseType = (): MiddlewareHandler<RpcResponseEnv> => {
 	return createMiddleware(async (c, next) => {
-		assertResponseTypeNotInitialized(c.var.response);
-
-		c.set('response', {
-			error: <T>(error?: T, id?: JsonRpc['id']) => {
-				return rpcError.parse({ error, id }) as TypedRpcError<T>;
-			},
-			result: <T>(result?: T, id?: JsonRpc['id']) => {
-				return rpcResult.parse({ id, result }) as TypedRpcResult<T>;
-			},
-			type: 'rpc',
-		});
+		if (c.var.response === undefined) {
+			c.set('response', {
+				error: <T>(error?: T, id?: JsonRpc['id']) => {
+					return rpcError.parse({ error, id }) as TypedRpcError<T>;
+				},
+				result: <T>(result?: T, id?: JsonRpc['id']) => {
+					return rpcResult.parse({ id, result }) as TypedRpcResult<T>;
+				},
+				type: 'rpc',
+			});
+		}
 
 		await next();
 	});