@rexeus/typeweaver-hono 0.7.0 → 0.9.0

package/README.md

@@ -29,7 +29,7 @@ npm install @rexeus/typeweaver-core
 ## 💡 How to use
 
 ```bash
-npx typeweaver generate --input ./api/definition --output ./api/generated --plugins hono
+npx typeweaver generate --input ./api/spec/index.ts --output ./api/generated --plugins hono
 ```
 
 More on the CLI in
@@ -51,28 +51,28 @@ Implement your handlers and mount the generated router in a Hono app.
 // api/user-handlers.ts
 import type { Context } from "hono";
 import { HttpStatusCode } from "@rexeus/typeweaver-core";
-import type { IGetUserRequest, GetUserResponse, UserNotFoundErrorResponse } from "./generated";
-import { GetUserSuccessResponse } from "./generated";
+import type { HonoUserApiHandler, IGetUserRequest, GetUserResponse } from "./generated";
+import { createUserNotFoundErrorResponse, createGetUserSuccessResponse } from "./generated";
 
 export class UserHandlers implements HonoUserApiHandler {
-    async handleGetUserRequest(request: IGetUserRequest, context: Context): Promise<GetUserResponse> {
-      // Symbolic database fetch
-      const databaseResult = {} as any;
-      if (!databaseResult) {
-        // Will be properly handled by the generated router and returned as a 404 response
-        return new UserNotFoundErrorResponse({
-          statusCode: HttpStatusCode.NotFound,
-          header: { "Content-Type": "application/json" },
-          body: { message: "User not found" },
-        });
-      }
-
-      return new GetUserSuccessResponse({
-        statusCode: HttpStatusCode.OK,
+  async handleGetUserRequest(request: IGetUserRequest, context: Context): Promise<GetUserResponse> {
+    const user = await db.findUser(request.param.userId);
+    if (!user) {
+      return createUserNotFoundErrorResponse({
         header: { "Content-Type": "application/json" },
-        body: { id: request.param.userId, name: "Jane", email: "jane@example.com" },
+        body: { message: "User not found" },
       });
-  },
+    }
+
+    return createGetUserSuccessResponse({
+      header: { "Content-Type": "application/json" },
+      body: {
+        id: request.param.userId,
+        name: "Jane",
+        email: "jane@example.com",
+      },
+    });
+  }
   // Implement other operation handlers: handleCreateUserRequest, ...
 }
 ```
@@ -91,8 +91,10 @@ const userHandlers = new UserHandlers();
 const userRouter = new UserHono({
   requestHandlers: userHandlers,
   validateRequests: true, // default, validates requests
-  handleValidationErrors: true, // default: returns 400 with issues
-  handleHttpResponseErrors: true, // default: returns thrown HttpResponse as-is
+  validateResponses: true, // default, validates responses and strips extra fields
+  handleRequestValidationErrors: true, // default: returns 400 with issues
+  handleResponseValidationErrors: true, // default: returns 500
+  handleHttpResponseErrors: true, // default: returns thrown typed HTTP responses as-is
   handleUnknownErrors: true, // default: returns 500
 });
 
@@ -110,14 +112,27 @@ serve({ fetch: app.fetch, port: 3000 }, () => {
 
 - `requestHandlers`: object implementing the generated `Hono<ResourceName>ApiHandler` type
 - `validateRequests` (default: `true`): enable/disable request validation
-- `handleValidationErrors`: `true` | `false` | `(err, c) => IHttpResponse | Promise<IHttpResponse>`,
+- `validateResponses` (default: `true`): enable/disable response validation. When enabled, responses
+  are validated against the operation's schema and extra body fields are stripped before sending.
+- `handleRequestValidationErrors`: `true` | `false` |
+  `(err, c) => IHttpResponse | Promise<IHttpResponse>`
   - If `true` (default), returns `400 Bad Request` with validation issues in the body
   - If `false`, disables this handler (errors fall through to the unknown error handler)
   - If function, calls the function with the error and context, expects an `IHttpResponse` to
     return, so you can customize the response in the way you want
+- `handleResponseValidationErrors`: `true` | `false` |
+  `(err, response, c) => IHttpResponse | Promise<IHttpResponse>`
+  - If `true` (default), returns `500 Internal Server Error`
+  - If `false`, disables response validation error handling — the invalid response is returned
+    as-is. Validation still runs (and strips extra fields on valid responses), but invalid responses
+    pass through unchanged. Useful when you want field stripping without blocking invalid responses.
+  - If function, calls the function with the `ResponseValidationError`, the original (invalid)
+    response, and the Hono context. The function should return an `IHttpResponse`. If the custom
+    handler throws, the original response is returned as a fallback.
 - `handleHttpResponseErrors`: `true` | `false` |
   `(err, c) => IHttpResponse | Promise<IHttpResponse>`
-  - If `true` (default), returns thrown `HttpResponse` as-is, they will be sent as the response
+  - If `true` (default), returns thrown typed HTTP responses (`ITypedHttpResponse`) as-is, they will
+    be sent as the response
   - If `false`, disables this handler (errors fall through to the unknown error handler)
   - If function, calls the function with the error and context, expects an `IHttpResponse` to
     return, so you can customize the response in the way you want

package/dist/index.cjs

@@ -6,16 +6,12 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") {
-		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-			key = keys[i];
-			if (!__hasOwnProp.call(to, key) && key !== except) {
-				__defProp(to, key, {
-					get: ((k) => from[k]).bind(null, key),
-					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-				});
-			}
-		}
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
 	}
 	return to;
 };
@@ -23,7 +19,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	value: mod,
 	enumerable: true
 }) : target, mod));
-
 //#endregion
 let node_path = require("node:path");
 node_path = __toESM(node_path);
@@ -32,65 +27,37 @@ let _rexeus_typeweaver_gen = require("@rexeus/typeweaver-gen");
 let _rexeus_typeweaver_core = require("@rexeus/typeweaver-core");
 let case$1 = require("case");
 case$1 = __toESM(case$1);
-
-//#region src/HonoRouterGenerator.ts
-var HonoRouterGenerator = class {
-	static generate(context) {
-		const moduleDir = node_path.default.dirname((0, node_url.fileURLToPath)(require("url").pathToFileURL(__filename).href));
-		const templateFile = node_path.default.join(moduleDir, "templates", "HonoRouter.ejs");
-		for (const [entityName, entityResource] of Object.entries(context.resources.entityResources)) this.writeHonoRouter(entityName, templateFile, entityResource.operations, context);
-	}
-	static writeHonoRouter(entityName, templateFile, operationResources, context) {
-		const pascalCaseEntityName = case$1.default.pascal(entityName);
-		const outputDir = node_path.default.join(context.outputDir, entityName);
-		const outputPath = node_path.default.join(outputDir, `${pascalCaseEntityName}Hono.ts`);
-		const operations = operationResources.filter((resource) => resource.definition.method !== _rexeus_typeweaver_core.HttpMethod.HEAD).map((resource) => this.createOperationData(resource)).sort((a, b) => this.compareRoutes(a, b));
-		const content = context.renderTemplate(templateFile, {
-			coreDir: node_path.default.relative(outputDir, context.outputDir),
-			entityName,
-			pascalCaseEntityName,
-			operations
-		});
-		const relativePath = node_path.default.relative(context.outputDir, outputPath);
-		context.writeFile(relativePath, content);
-	}
-	static createOperationData(resource) {
-		const operationId = resource.definition.operationId;
-		const className = case$1.default.pascal(operationId);
-		return {
-			operationId,
-			className,
-			handlerName: `handle${className}Request`,
-			method: resource.definition.method,
-			path: resource.definition.path
-		};
-	}
-	static compareRoutes(a, b) {
-		const aSegments = a.path.split("/").filter((s) => s);
-		const bSegments = b.path.split("/").filter((s) => s);
-		if (aSegments.length !== bSegments.length) return aSegments.length - bSegments.length;
-		for (let i = 0; i < aSegments.length; i++) {
-			const aSegment = aSegments[i];
-			const bSegment = bSegments[i];
-			const aIsParam = aSegment.startsWith(":");
-			if (aIsParam !== bSegment.startsWith(":")) return aIsParam ? 1 : -1;
-			if (aSegment !== bSegment) return aSegment.localeCompare(bSegment);
-		}
-		return this.getMethodPriority(a.method) - this.getMethodPriority(b.method);
-	}
-	static getMethodPriority(method) {
-		return {
-			GET: 1,
-			POST: 2,
-			PUT: 3,
-			PATCH: 4,
-			DELETE: 5,
-			OPTIONS: 6,
-			HEAD: 7
-		}[method] ?? 999;
-	}
-};
-
+//#region src/honoRouterGenerator.ts
+function generate(context) {
+	const moduleDir = node_path.default.dirname((0, node_url.fileURLToPath)(require("url").pathToFileURL(__filename).href));
+	const templateFile = node_path.default.join(moduleDir, "templates", "HonoRouter.ejs");
+	for (const resource of context.normalizedSpec.resources) writeHonoRouter(resource, templateFile, context);
+}
+function writeHonoRouter(resource, templateFile, context) {
+	const pascalCaseEntityName = case$1.default.pascal(resource.name);
+	const outputDir = context.getResourceOutputDir(resource.name);
+	const outputPath = node_path.default.join(outputDir, `${pascalCaseEntityName}Hono.ts`);
+	const operations = resource.operations.filter((operation) => operation.method !== _rexeus_typeweaver_core.HttpMethod.HEAD).map((operation) => createOperationData(operation)).sort((a, b) => (0, _rexeus_typeweaver_gen.compareRoutes)(a, b));
+	const content = context.renderTemplate(templateFile, {
+		coreDir: node_path.default.relative(outputDir, context.outputDir),
+		entityName: resource.name,
+		pascalCaseEntityName,
+		operations
+	});
+	const relativePath = node_path.default.relative(context.outputDir, outputPath);
+	context.writeFile(relativePath, content);
+}
+function createOperationData(operation) {
+	const operationId = operation.operationId;
+	const className = case$1.default.pascal(operationId);
+	return {
+		operationId,
+		className,
+		handlerName: `handle${className}Request`,
+		method: operation.method,
+		path: operation.path
+	};
+}
 //#endregion
 //#region src/index.ts
 const moduleDir = node_path.default.dirname((0, node_url.fileURLToPath)(require("url").pathToFileURL(__filename).href));
@@ -99,9 +66,8 @@ var HonoPlugin = class extends _rexeus_typeweaver_gen.BasePlugin {
 	generate(context) {
 		const libSourceDir = node_path.default.join(moduleDir, "lib");
 		this.copyLibFiles(context, libSourceDir, this.name);
-		HonoRouterGenerator.generate(context);
+		generate(context);
 	}
 };
-
 //#endregion
-module.exports = HonoPlugin;
+module.exports = HonoPlugin;

package/dist/index.mjs

@@ -1,67 +1,39 @@
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { BasePlugin } from "@rexeus/typeweaver-gen";
+import { BasePlugin, compareRoutes } from "@rexeus/typeweaver-gen";
 import { HttpMethod } from "@rexeus/typeweaver-core";
 import Case from "case";
-
-//#region src/HonoRouterGenerator.ts
-var HonoRouterGenerator = class {
-	static generate(context) {
-		const moduleDir = path.dirname(fileURLToPath(import.meta.url));
-		const templateFile = path.join(moduleDir, "templates", "HonoRouter.ejs");
-		for (const [entityName, entityResource] of Object.entries(context.resources.entityResources)) this.writeHonoRouter(entityName, templateFile, entityResource.operations, context);
-	}
-	static writeHonoRouter(entityName, templateFile, operationResources, context) {
-		const pascalCaseEntityName = Case.pascal(entityName);
-		const outputDir = path.join(context.outputDir, entityName);
-		const outputPath = path.join(outputDir, `${pascalCaseEntityName}Hono.ts`);
-		const operations = operationResources.filter((resource) => resource.definition.method !== HttpMethod.HEAD).map((resource) => this.createOperationData(resource)).sort((a, b) => this.compareRoutes(a, b));
-		const content = context.renderTemplate(templateFile, {
-			coreDir: path.relative(outputDir, context.outputDir),
-			entityName,
-			pascalCaseEntityName,
-			operations
-		});
-		const relativePath = path.relative(context.outputDir, outputPath);
-		context.writeFile(relativePath, content);
-	}
-	static createOperationData(resource) {
-		const operationId = resource.definition.operationId;
-		const className = Case.pascal(operationId);
-		return {
-			operationId,
-			className,
-			handlerName: `handle${className}Request`,
-			method: resource.definition.method,
-			path: resource.definition.path
-		};
-	}
-	static compareRoutes(a, b) {
-		const aSegments = a.path.split("/").filter((s) => s);
-		const bSegments = b.path.split("/").filter((s) => s);
-		if (aSegments.length !== bSegments.length) return aSegments.length - bSegments.length;
-		for (let i = 0; i < aSegments.length; i++) {
-			const aSegment = aSegments[i];
-			const bSegment = bSegments[i];
-			const aIsParam = aSegment.startsWith(":");
-			if (aIsParam !== bSegment.startsWith(":")) return aIsParam ? 1 : -1;
-			if (aSegment !== bSegment) return aSegment.localeCompare(bSegment);
-		}
-		return this.getMethodPriority(a.method) - this.getMethodPriority(b.method);
-	}
-	static getMethodPriority(method) {
-		return {
-			GET: 1,
-			POST: 2,
-			PUT: 3,
-			PATCH: 4,
-			DELETE: 5,
-			OPTIONS: 6,
-			HEAD: 7
-		}[method] ?? 999;
-	}
-};
-
+//#region src/honoRouterGenerator.ts
+function generate(context) {
+	const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+	const templateFile = path.join(moduleDir, "templates", "HonoRouter.ejs");
+	for (const resource of context.normalizedSpec.resources) writeHonoRouter(resource, templateFile, context);
+}
+function writeHonoRouter(resource, templateFile, context) {
+	const pascalCaseEntityName = Case.pascal(resource.name);
+	const outputDir = context.getResourceOutputDir(resource.name);
+	const outputPath = path.join(outputDir, `${pascalCaseEntityName}Hono.ts`);
+	const operations = resource.operations.filter((operation) => operation.method !== HttpMethod.HEAD).map((operation) => createOperationData(operation)).sort((a, b) => compareRoutes(a, b));
+	const content = context.renderTemplate(templateFile, {
+		coreDir: path.relative(outputDir, context.outputDir),
+		entityName: resource.name,
+		pascalCaseEntityName,
+		operations
+	});
+	const relativePath = path.relative(context.outputDir, outputPath);
+	context.writeFile(relativePath, content);
+}
+function createOperationData(operation) {
+	const operationId = operation.operationId;
+	const className = Case.pascal(operationId);
+	return {
+		operationId,
+		className,
+		handlerName: `handle${className}Request`,
+		method: operation.method,
+		path: operation.path
+	};
+}
 //#endregion
 //#region src/index.ts
 const moduleDir = path.dirname(fileURLToPath(import.meta.url));
@@ -70,10 +42,10 @@ var HonoPlugin = class extends BasePlugin {
 	generate(context) {
 		const libSourceDir = path.join(moduleDir, "lib");
 		this.copyLibFiles(context, libSourceDir, this.name);
-		HonoRouterGenerator.generate(context);
+		generate(context);
 	}
 };
-
 //#endregion
 export { HonoPlugin as default };
+
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../src/HonoRouterGenerator.ts","../src/index.ts"],"sourcesContent":["import path from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\nimport { HttpMethod } from \"@rexeus/typeweaver-core\";\nimport type {\n  GeneratorContext,\n  OperationResource,\n} from \"@rexeus/typeweaver-gen\";\nimport Case from \"case\";\n\nexport class HonoRouterGenerator {\n  public static generate(context: GeneratorContext): void {\n    const moduleDir = path.dirname(fileURLToPath(import.meta.url));\n    const templateFile = path.join(moduleDir, \"templates\", \"HonoRouter.ejs\");\n\n    for (const [entityName, entityResource] of Object.entries(\n      context.resources.entityResources\n    )) {\n      this.writeHonoRouter(\n        entityName,\n        templateFile,\n        entityResource.operations,\n        context\n      );\n    }\n  }\n\n  private static writeHonoRouter(\n    entityName: string,\n    templateFile: string,\n    operationResources: OperationResource[],\n    context: GeneratorContext\n  ): void {\n    const pascalCaseEntityName = Case.pascal(entityName);\n    const outputDir = path.join(context.outputDir, entityName);\n    const outputPath = path.join(outputDir, `${pascalCaseEntityName}Hono.ts`);\n\n    const operations = operationResources\n      // Hono handles HEAD requests automatically, so we skip them\n      .filter(resource => resource.definition.method !== HttpMethod.HEAD)\n      .map(resource => this.createOperationData(resource))\n      .sort((a, b) => this.compareRoutes(a, b));\n\n    const content = context.renderTemplate(templateFile, {\n      coreDir: path.relative(outputDir, context.outputDir),\n      entityName,\n      pascalCaseEntityName,\n      operations,\n    });\n\n    const relativePath = path.relative(context.outputDir, outputPath);\n    context.writeFile(relativePath, content);\n  }\n\n  private static createOperationData(resource: OperationResource) {\n    const operationId = resource.definition.operationId;\n    const className = Case.pascal(operationId);\n    const handlerName = `handle${className}Request`;\n\n    return {\n      operationId,\n      className,\n      handlerName,\n      method: resource.definition.method,\n      path: resource.definition.path,\n    };\n  }\n\n  private static compareRoutes(\n    a: ReturnType<typeof HonoRouterGenerator.createOperationData>,\n    b: ReturnType<typeof HonoRouterGenerator.createOperationData>\n  ): number {\n    const aSegments = a.path.split(\"/\").filter(s => s);\n    const bSegments = b.path.split(\"/\").filter(s => s);\n\n    // 1. Compare by depth first (shallow to deep)\n    if (aSegments.length !== bSegments.length) {\n      return aSegments.length - bSegments.length;\n    }\n\n    // 2. Compare segment by segment\n    for (let i = 0; i < aSegments.length; i++) {\n      const aSegment = aSegments[i]!;\n      const bSegment = bSegments[i]!;\n\n      const aIsParam = aSegment.startsWith(\":\");\n      const bIsParam = bSegment.startsWith(\":\");\n\n      // Static segments before parameters\n      if (aIsParam !== bIsParam) {\n        return aIsParam ? 1 : -1;\n      }\n\n      // Within same type, alphabetical order\n      if (aSegment !== bSegment) {\n        return aSegment.localeCompare(bSegment);\n      }\n    }\n\n    // 3. Same path = sort by HTTP method priority\n    return this.getMethodPriority(a.method) - this.getMethodPriority(b.method);\n  }\n\n  private static getMethodPriority(method: string): number {\n    const priorities: Record<string, number> = {\n      GET: 1,\n      POST: 2,\n      PUT: 3,\n      PATCH: 4,\n      DELETE: 5,\n      OPTIONS: 6,\n      HEAD: 7,\n    };\n    return priorities[method] ?? 999;\n  }\n}\n","import path from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\nimport { BasePlugin } from \"@rexeus/typeweaver-gen\";\nimport type { GeneratorContext } from \"@rexeus/typeweaver-gen\";\nimport { HonoRouterGenerator } from \"./HonoRouterGenerator\";\n\nconst moduleDir = path.dirname(fileURLToPath(import.meta.url));\n\nexport default class HonoPlugin extends BasePlugin {\n  public name = \"hono\";\n\n  public override generate(context: GeneratorContext): void {\n    const libSourceDir = path.join(moduleDir, \"lib\");\n    this.copyLibFiles(context, libSourceDir, this.name);\n\n    HonoRouterGenerator.generate(context);\n  }\n}\n"],"mappings":";;;;;;;AASA,IAAa,sBAAb,MAAiC;CAC/B,OAAc,SAAS,SAAiC;EACtD,MAAM,YAAY,KAAK,QAAQ,cAAc,OAAO,KAAK,IAAI,CAAC;EAC9D,MAAM,eAAe,KAAK,KAAK,WAAW,aAAa,iBAAiB;AAExE,OAAK,MAAM,CAAC,YAAY,mBAAmB,OAAO,QAChD,QAAQ,UAAU,gBACnB,CACC,MAAK,gBACH,YACA,cACA,eAAe,YACf,QACD;;CAIL,OAAe,gBACb,YACA,cACA,oBACA,SACM;EACN,MAAM,uBAAuB,KAAK,OAAO,WAAW;EACpD,MAAM,YAAY,KAAK,KAAK,QAAQ,WAAW,WAAW;EAC1D,MAAM,aAAa,KAAK,KAAK,WAAW,GAAG,qBAAqB,SAAS;EAEzE,MAAM,aAAa,mBAEhB,QAAO,aAAY,SAAS,WAAW,WAAW,WAAW,KAAK,CAClE,KAAI,aAAY,KAAK,oBAAoB,SAAS,CAAC,CACnD,MAAM,GAAG,MAAM,KAAK,cAAc,GAAG,EAAE,CAAC;EAE3C,MAAM,UAAU,QAAQ,eAAe,cAAc;GACnD,SAAS,KAAK,SAAS,WAAW,QAAQ,UAAU;GACpD;GACA;GACA;GACD,CAAC;EAEF,MAAM,eAAe,KAAK,SAAS,QAAQ,WAAW,WAAW;AACjE,UAAQ,UAAU,cAAc,QAAQ;;CAG1C,OAAe,oBAAoB,UAA6B;EAC9D,MAAM,cAAc,SAAS,WAAW;EACxC,MAAM,YAAY,KAAK,OAAO,YAAY;AAG1C,SAAO;GACL;GACA;GACA,aALkB,SAAS,UAAU;GAMrC,QAAQ,SAAS,WAAW;GAC5B,MAAM,SAAS,WAAW;GAC3B;;CAGH,OAAe,cACb,GACA,GACQ;EACR,MAAM,YAAY,EAAE,KAAK,MAAM,IAAI,CAAC,QAAO,MAAK,EAAE;EAClD,MAAM,YAAY,EAAE,KAAK,MAAM,IAAI,CAAC,QAAO,MAAK,EAAE;AAGlD,MAAI,UAAU,WAAW,UAAU,OACjC,QAAO,UAAU,SAAS,UAAU;AAItC,OAAK,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;GACzC,MAAM,WAAW,UAAU;GAC3B,MAAM,WAAW,UAAU;GAE3B,MAAM,WAAW,SAAS,WAAW,IAAI;AAIzC,OAAI,aAHa,SAAS,WAAW,IAAI,CAIvC,QAAO,WAAW,IAAI;AAIxB,OAAI,aAAa,SACf,QAAO,SAAS,cAAc,SAAS;;AAK3C,SAAO,KAAK,kBAAkB,EAAE,OAAO,GAAG,KAAK,kBAAkB,EAAE,OAAO;;CAG5E,OAAe,kBAAkB,QAAwB;AAUvD,SAT2C;GACzC,KAAK;GACL,MAAM;GACN,KAAK;GACL,OAAO;GACP,QAAQ;GACR,SAAS;GACT,MAAM;GACP,CACiB,WAAW;;;;;;AC1GjC,MAAM,YAAY,KAAK,QAAQ,cAAc,OAAO,KAAK,IAAI,CAAC;AAE9D,IAAqB,aAArB,cAAwC,WAAW;CACjD,AAAO,OAAO;CAEd,AAAgB,SAAS,SAAiC;EACxD,MAAM,eAAe,KAAK,KAAK,WAAW,MAAM;AAChD,OAAK,aAAa,SAAS,cAAc,KAAK,KAAK;AAEnD,sBAAoB,SAAS,QAAQ"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/honoRouterGenerator.ts","../src/index.ts"],"sourcesContent":["import path from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\nimport { HttpMethod } from \"@rexeus/typeweaver-core\";\nimport { compareRoutes } from \"@rexeus/typeweaver-gen\";\nimport type {\n  GeneratorContext,\n  NormalizedOperation,\n  NormalizedResource,\n} from \"@rexeus/typeweaver-gen\";\nimport Case from \"case\";\n\nexport function generate(context: GeneratorContext): void {\n  const moduleDir = path.dirname(fileURLToPath(import.meta.url));\n  const templateFile = path.join(moduleDir, \"templates\", \"HonoRouter.ejs\");\n\n  for (const resource of context.normalizedSpec.resources) {\n    writeHonoRouter(resource, templateFile, context);\n  }\n}\n\nfunction writeHonoRouter(\n  resource: NormalizedResource,\n  templateFile: string,\n  context: GeneratorContext\n): void {\n  const pascalCaseEntityName = Case.pascal(resource.name);\n  const outputDir = context.getResourceOutputDir(resource.name);\n  const outputPath = path.join(outputDir, `${pascalCaseEntityName}Hono.ts`);\n\n  const operations = resource.operations\n    // Hono handles HEAD requests automatically, so we skip them\n    .filter(operation => operation.method !== HttpMethod.HEAD)\n    .map(operation => createOperationData(operation))\n    .sort((a, b) => compareRoutes(a, b));\n\n  const content = context.renderTemplate(templateFile, {\n    coreDir: path.relative(outputDir, context.outputDir),\n    entityName: resource.name,\n    pascalCaseEntityName,\n    operations,\n  });\n\n  const relativePath = path.relative(context.outputDir, outputPath);\n  context.writeFile(relativePath, content);\n}\n\nfunction createOperationData(operation: NormalizedOperation) {\n  const operationId = operation.operationId;\n  const className = Case.pascal(operationId);\n  const handlerName = `handle${className}Request`;\n\n  return {\n    operationId,\n    className,\n    handlerName,\n    method: operation.method,\n    path: operation.path,\n  };\n}\n","import path from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\nimport { BasePlugin } from \"@rexeus/typeweaver-gen\";\nimport type { GeneratorContext } from \"@rexeus/typeweaver-gen\";\nimport { generate as generateHonoRouters } from \"./honoRouterGenerator\";\n\nconst moduleDir = path.dirname(fileURLToPath(import.meta.url));\n\nexport default class HonoPlugin extends BasePlugin {\n  public name = \"hono\";\n\n  public override generate(context: GeneratorContext): void {\n    const libSourceDir = path.join(moduleDir, \"lib\");\n    this.copyLibFiles(context, libSourceDir, this.name);\n\n    generateHonoRouters(context);\n  }\n}\n"],"mappings":";;;;;;AAWA,SAAgB,SAAS,SAAiC;CACxD,MAAM,YAAY,KAAK,QAAQ,cAAc,OAAO,KAAK,IAAI,CAAC;CAC9D,MAAM,eAAe,KAAK,KAAK,WAAW,aAAa,iBAAiB;AAExE,MAAK,MAAM,YAAY,QAAQ,eAAe,UAC5C,iBAAgB,UAAU,cAAc,QAAQ;;AAIpD,SAAS,gBACP,UACA,cACA,SACM;CACN,MAAM,uBAAuB,KAAK,OAAO,SAAS,KAAK;CACvD,MAAM,YAAY,QAAQ,qBAAqB,SAAS,KAAK;CAC7D,MAAM,aAAa,KAAK,KAAK,WAAW,GAAG,qBAAqB,SAAS;CAEzE,MAAM,aAAa,SAAS,WAEzB,QAAO,cAAa,UAAU,WAAW,WAAW,KAAK,CACzD,KAAI,cAAa,oBAAoB,UAAU,CAAC,CAChD,MAAM,GAAG,MAAM,cAAc,GAAG,EAAE,CAAC;CAEtC,MAAM,UAAU,QAAQ,eAAe,cAAc;EACnD,SAAS,KAAK,SAAS,WAAW,QAAQ,UAAU;EACpD,YAAY,SAAS;EACrB;EACA;EACD,CAAC;CAEF,MAAM,eAAe,KAAK,SAAS,QAAQ,WAAW,WAAW;AACjE,SAAQ,UAAU,cAAc,QAAQ;;AAG1C,SAAS,oBAAoB,WAAgC;CAC3D,MAAM,cAAc,UAAU;CAC9B,MAAM,YAAY,KAAK,OAAO,YAAY;AAG1C,QAAO;EACL;EACA;EACA,aALkB,SAAS,UAAU;EAMrC,QAAQ,UAAU;EAClB,MAAM,UAAU;EACjB;;;;ACnDH,MAAM,YAAY,KAAK,QAAQ,cAAc,OAAO,KAAK,IAAI,CAAC;AAE9D,IAAqB,aAArB,cAAwC,WAAW;CACjD,OAAc;CAEd,SAAyB,SAAiC;EACxD,MAAM,eAAe,KAAK,KAAK,WAAW,MAAM;AAChD,OAAK,aAAa,SAAS,cAAc,KAAK,KAAK;AAEnD,WAAoB,QAAQ"}

package/dist/lib/TypeweaverHono.ts

@@ -5,11 +5,21 @@
  * @generated by @rexeus/typeweaver
  */
 
-import { HttpResponse, RequestValidationError } from "@rexeus/typeweaver-core";
+import {
+  createDefaultErrorBody,
+  createDefaultErrorResponse,
+  internalServerErrorDefaultError,
+  isTypedHttpResponse,
+  RequestValidationError,
+  validationDefaultError,
+} from "@rexeus/typeweaver-core";
 import type {
   IHttpRequest,
   IHttpResponse,
   IRequestValidator,
+  IResponseValidator,
+  ITypedHttpResponse,
+  ResponseValidationError,
 } from "@rexeus/typeweaver-core";
 import { Hono } from "hono";
 import { HonoAdapter } from "./HonoAdapter";
@@ -25,7 +35,7 @@ import type { BlankEnv, BlankSchema, Env, Schema } from "hono/types";
  * @returns The HTTP response to send to the client
  */
 export type HonoHttpResponseErrorHandler = (
-  error: HttpResponse,
+  error: ITypedHttpResponse,
   context: Context
 ) => Promise<IHttpResponse> | IHttpResponse;
 
@@ -35,7 +45,7 @@ export type HonoHttpResponseErrorHandler = (
  * @param context - The Hono context for the current request
  * @returns The HTTP response to send to the client
  */
-export type HonoValidationErrorHandler = (
+export type HonoRequestValidationErrorHandler = (
   error: RequestValidationError,
   context: Context
 ) => Promise<IHttpResponse> | IHttpResponse;
@@ -51,6 +61,20 @@ export type HonoUnknownErrorHandler = (
   context: Context
 ) => Promise<IHttpResponse> | IHttpResponse;
 
+/**
+ * Handles response validation errors.
+ * Called when a handler returns a response that does not match the expected schema.
+ * @param error - The response validation error with schema mismatch details
+ * @param response - The original (invalid) response from the handler
+ * @param context - The Hono context for the current request
+ * @returns The HTTP response to send to the client (typically a 500)
+ */
+export type HonoResponseValidationErrorHandler = (
+  error: ResponseValidationError,
+  response: IHttpResponse,
+  context: Context
+) => Promise<IHttpResponse> | IHttpResponse;
+
 /**
  * Configuration options for TypeweaverHono routers.
  * @template RequestHandlers - Type containing all request handler methods
@@ -64,32 +88,52 @@ export type TypeweaverHonoOptions<
    * Request handler methods for each operation.
    * Each handler receives a request (validated if `validateRequests` is true) and Hono context.
    */
-  requestHandlers: RequestHandlers;
+  readonly requestHandlers: RequestHandlers;
 
   /**
    * Enable request validation using generated validators.
    * When false, requests are passed through without validation.
    * @default true
    */
-  validateRequests?: boolean;
+  readonly validateRequests?: boolean;
 
   /**
-   * Configure handling of HttpResponse errors thrown by handlers.
-   * - `true`: Use default handler (returns the error as-is)
-   * - `false`: Let errors bubble up to Hono
-   * - `function`: Use custom error handler
+   * Enable response validation using generated validators.
+   * When true, responses are validated and stripped of extra fields before sending.
    * @default true
    */
-  handleHttpResponseErrors?: HonoHttpResponseErrorHandler | boolean;
+  readonly validateResponses?: boolean;
 
   /**
    * Configure handling of request validation errors.
    * - `true`: Use default handler (400 with error details)
    * - `false`: Let errors bubble up to Hono
+   * - `function`: Use custom request validation error handler
+   * @default true
+   */
+  readonly handleRequestValidationErrors?:
+    | HonoRequestValidationErrorHandler
+    | boolean;
+
+  /**
+   * Configure handling of response validation errors.
+   * - `true`: Use default handler (500 Internal Server Error)
+   * - `false`: Disable response validation error handling (return response as-is)
+   * - `function`: Use custom response validation error handler
+   * @default true
+   */
+  readonly handleResponseValidationErrors?:
+    | HonoResponseValidationErrorHandler
+    | boolean;
+
+  /**
+   * Configure handling of HttpResponse errors thrown by handlers.
+   * - `true`: Use default handler (returns the error as-is)
+   * - `false`: Let errors bubble up to Hono
    * - `function`: Use custom error handler
    * @default true
    */
-  handleValidationErrors?: HonoValidationErrorHandler | boolean;
+  readonly handleHttpResponseErrors?: HonoHttpResponseErrorHandler | boolean;
 
   /**
    * Configure handling of unknown errors.
@@ -98,7 +142,7 @@ export type TypeweaverHonoOptions<
    * - `function`: Use custom error handler
    * @default true
    */
-  handleUnknownErrors?: HonoUnknownErrorHandler | boolean;
+  readonly handleUnknownErrors?: HonoUnknownErrorHandler | boolean;
 };
 
 /**
@@ -134,11 +178,15 @@ export abstract class TypeweaverHono<
    * Resolved configuration for validation and error handling.
    */
   private readonly config: {
-    validateRequests: boolean;
-    errorHandlers: {
-      validation: HonoValidationErrorHandler | undefined;
-      httpResponse: HonoHttpResponseErrorHandler | undefined;
-      unknown: HonoUnknownErrorHandler | undefined;
+    readonly validateRequests: boolean;
+    readonly validateResponses: boolean;
+    readonly errorHandlers: {
+      readonly requestValidation: HonoRequestValidationErrorHandler | undefined;
+      readonly responseValidation:
+        | HonoResponseValidationErrorHandler
+        | undefined;
+      readonly httpResponse: HonoHttpResponseErrorHandler | undefined;
+      readonly unknown: HonoUnknownErrorHandler | undefined;
     };
   };
 
@@ -146,11 +194,10 @@ export abstract class TypeweaverHono<
    * Default error handlers used when custom handlers are not provided.
    */
   private readonly defaultHandlers = {
-    validation: (error: RequestValidationError): IHttpResponse => ({
-      statusCode: 400,
+    requestValidation: (error: RequestValidationError): IHttpResponse => ({
+      statusCode: validationDefaultError.statusCode,
       body: {
-        code: "VALIDATION_ERROR",
-        message: error.message,
+        ...createDefaultErrorBody(validationDefaultError),
         issues: {
           header: error.headerIssues,
           body: error.bodyIssues,
@@ -160,15 +207,13 @@ export abstract class TypeweaverHono<
       },
     }),
 
-    httpResponse: (error: HttpResponse): IHttpResponse => error,
+    responseValidation: (): IHttpResponse =>
+      createDefaultErrorResponse(internalServerErrorDefaultError),
 
-    unknown: (): IHttpResponse => ({
-      statusCode: 500,
-      body: {
-        code: "INTERNAL_SERVER_ERROR",
-        message: "An unexpected error occurred.",
-      },
-    }),
+    httpResponse: (error: ITypedHttpResponse): IHttpResponse => error,
+
+    unknown: (): IHttpResponse =>
+      createDefaultErrorResponse(internalServerErrorDefaultError),
   };
 
   /**
@@ -178,15 +223,17 @@ export abstract class TypeweaverHono<
    * @param options.requestHandlers - Object containing all request handler methods
    * @param options.validateRequests - Whether to validate requests (default: true)
    * @param options.handleHttpResponseErrors - Handler or boolean for HTTP errors (default: true)
-   * @param options.handleValidationErrors - Handler or boolean for validation errors (default: true)
+   * @param options.handleRequestValidationErrors - Handler or boolean for request validation errors (default: true)
    * @param options.handleUnknownErrors - Handler or boolean for unknown errors (default: true)
    */
   public constructor(options: TypeweaverHonoOptions<RequestHandlers, HonoEnv>) {
     const {
       requestHandlers,
       validateRequests = true,
+      validateResponses = true,
       handleHttpResponseErrors,
-      handleValidationErrors,
+      handleRequestValidationErrors,
+      handleResponseValidationErrors,
       handleUnknownErrors,
       ...honoOptions
     } = options;
@@ -198,9 +245,15 @@ export abstract class TypeweaverHono<
     // Resolve configuration
     this.config = {
       validateRequests,
+      validateResponses,
       errorHandlers: {
-        validation: this.resolveErrorHandler(handleValidationErrors, error =>
-          this.defaultHandlers.validation(error)
+        requestValidation: this.resolveErrorHandler(
+          handleRequestValidationErrors,
+          error => this.defaultHandlers.requestValidation(error)
+        ),
+        responseValidation: this.resolveErrorHandler(
+          handleResponseValidationErrors,
+          (_error, _response) => this.defaultHandlers.responseValidation()
         ),
         httpResponse: this.resolveErrorHandler(
           handleHttpResponseErrors,
@@ -239,24 +292,29 @@ export abstract class TypeweaverHono<
    * Processes errors in order: validation, HTTP response, unknown.
    */
   protected registerErrorHandler(): void {
-    this.onError(this.handleError.bind(this));
+    this.onError(async (error, context) =>
+      this.adapter.toResponse(await this.handleError(error, context))
+    );
   }
 
   /**
    * Safely executes an error handler and returns null if it fails.
-   * This allows for graceful fallback to the next handler in the chain.
+   * This allows for graceful fallback to the next handler in the chain
+   * without crashing the request pipeline.
    *
    * @param handlerFn - Function that executes the error handler
-   * @returns Response if successful, null if handler throws
+   * @returns The handler's response if successful, null if the handler throws
    */
-  private async safelyExecuteHandler(
+  private async safelyExecuteErrorHandler(
     handlerFn: () => Promise<IHttpResponse> | IHttpResponse
-  ): Promise<Response | null> {
+  ): Promise<IHttpResponse | null> {
     try {
-      const response = await handlerFn();
-      return this.adapter.toResponse(response);
-    } catch {
-      // Handler execution failed, return null to continue to next handler
+      return await handlerFn();
+    } catch (error) {
+      console.error(
+        "TypeweaverHono: error handler threw while handling error",
+        error
+      );
       return null;
     }
   }
@@ -264,24 +322,21 @@ export abstract class TypeweaverHono<
   protected async handleError(
     error: unknown,
     context: Context
-  ): Promise<Response> {
+  ): Promise<IHttpResponse> {
     // Handle validation errors
     if (
       error instanceof RequestValidationError &&
-      this.config.errorHandlers.validation
+      this.config.errorHandlers.requestValidation
     ) {
-      const response = await this.safelyExecuteHandler(() =>
-        this.config.errorHandlers.validation!(error, context)
+      const response = await this.safelyExecuteErrorHandler(() =>
+        this.config.errorHandlers.requestValidation!(error, context)
       );
       if (response) return response;
     }
 
     // Handle HTTP response errors
-    if (
-      error instanceof HttpResponse &&
-      this.config.errorHandlers.httpResponse
-    ) {
-      const response = await this.safelyExecuteHandler(() =>
+    if (isTypedHttpResponse(error) && this.config.errorHandlers.httpResponse) {
+      const response = await this.safelyExecuteErrorHandler(() =>
         this.config.errorHandlers.httpResponse!(error, context)
       );
       if (response) return response;
@@ -289,7 +344,7 @@ export abstract class TypeweaverHono<
 
     // Handle unknown errors
     if (this.config.errorHandlers.unknown) {
-      const response = await this.safelyExecuteHandler(() =>
+      const response = await this.safelyExecuteErrorHandler(() =>
         this.config.errorHandlers.unknown!(error, context)
       );
       if (response) return response;
@@ -304,7 +359,8 @@ export abstract class TypeweaverHono<
    *
    * @param context - Hono context for the current request
    * @param operationId - Unique operation identifier from the API definition
-   * @param validator - Request validator for the specific operation
+   * @param requestValidator - Request validator for the specific operation
+   * @param responseValidator - Response validator for the specific operation
    * @param handler - Type-safe request handler function
    * @returns Hono-compatible Response object
    */
@@ -314,7 +370,8 @@ export abstract class TypeweaverHono<
   >(
     context: Context,
     operationId: string,
-    validator: IRequestValidator,
+    requestValidator: IRequestValidator,
+    responseValidator: IResponseValidator,
     handler: HonoRequestHandler<TRequest, TResponse>
   ): Promise<Response> {
     try {
@@ -322,15 +379,67 @@ export abstract class TypeweaverHono<
 
       const httpRequest = await this.adapter.toRequest(context);
 
-      // Conditionally validate
       const validatedRequest = this.config.validateRequests
-        ? (validator.validate(httpRequest) as TRequest)
+        ? (requestValidator.validate(httpRequest) as TRequest)
         : (httpRequest as TRequest);
 
       const httpResponse = await handler(validatedRequest, context);
-      return this.adapter.toResponse(httpResponse);
+      return this.adapter.toResponse(
+        await this.validateResponse(responseValidator, httpResponse, context)
+      );
     } catch (error) {
-      return this.handleError(error, context);
+      if (isTypedHttpResponse(error) && this.config.validateResponses) {
+        const validated = await this.validateResponse(
+          responseValidator,
+          error,
+          context
+        );
+        return this.adapter.toResponse(validated);
+      }
+      return this.adapter.toResponse(await this.handleError(error, context));
+    }
+  }
+
+  /**
+   * Validates a response against the operation's response validator.
+   *
+   * Behavior depends on configuration:
+   * - `validateResponses: false` → returns the original response unchanged.
+   * - `validateResponses: true` (default) → runs validation:
+   *   - Valid response → returns the stripped response (extra fields removed).
+   *   - Invalid response + handler configured → calls the handler safely.
+   *     If the handler throws, falls back to the original response.
+   *   - Invalid response + `handleResponseValidationErrors: false` → returns
+   *     the original (invalid) response as-is.
+   *
+   * @param responseValidator - The response validator for the operation
+   * @param response - The response to validate
+   * @param context - The Hono context for the current request
+   * @returns The validated (and stripped) response, the handler's response, or the original
+   */
+  private async validateResponse(
+    responseValidator: IResponseValidator,
+    response: IHttpResponse,
+    context: Context
+  ): Promise<IHttpResponse> {
+    if (!this.config.validateResponses) return response;
+
+    const result = responseValidator.safeValidate(response);
+
+    if (result.isValid) return result.data;
+
+    if (this.config.errorHandlers.responseValidation) {
+      const handlerResponse = await this.safelyExecuteErrorHandler(() =>
+        this.config.errorHandlers.responseValidation!(
+          result.error,
+          response,
+          context
+        )
+      );
+
+      if (handlerResponse) return handlerResponse;
     }
+
+    return response;
   }
 }

package/dist/templates/HonoRouter.ejs

@@ -12,6 +12,7 @@ import { TypeweaverHono, type HonoRequestHandler, type TypeweaverHonoOptions } f
 import type { I<%- operation.className %>Request } from "./<%- operation.className %>Request";
 import { <%- operation.className %>RequestValidator } from "./<%- operation.className %>RequestValidator";
 import type { <%- operation.className %>Response } from "./<%- operation.className %>Response";
+import { <%- operation.className %>ResponseValidator } from "./<%- operation.className %>ResponseValidator";
 <% } %>
 
 export type Hono<%- pascalCaseEntityName %>ApiHandler = {
@@ -33,6 +34,7 @@ export class <%- pascalCaseEntityName %>Hono extends TypeweaverHono<Hono<%- pasc
         context,
         '<%- operation.operationId %>',
         new <%- operation.className %>RequestValidator(),
+        new <%- operation.className %>ResponseValidator(),
         this.requestHandlers.<%- operation.handlerName %>.bind(this.requestHandlers)
       ));
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rexeus/typeweaver-hono",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "Generates Hono routers and handlers straight from your API definitions. Powered by Typeweaver 🧵✨",
   "type": "module",
   "sideEffects": false,
@@ -47,20 +47,20 @@
   "homepage": "https://github.com/rexeus/typeweaver#readme",
   "peerDependencies": {
     "hono": "^4.11.0",
-    "@rexeus/typeweaver-core": "^0.7.0",
-    "@rexeus/typeweaver-gen": "^0.7.0"
+    "@rexeus/typeweaver-core": "^0.9.0",
+    "@rexeus/typeweaver-gen": "^0.9.0"
   },
   "devDependencies": {
-    "hono": "^4.11.3",
+    "hono": "^4.12.9",
     "test-utils": "file:../test-utils",
-    "@rexeus/typeweaver-core": "^0.7.0",
-    "@rexeus/typeweaver-gen": "^0.7.0"
+    "@rexeus/typeweaver-core": "^0.9.0",
+    "@rexeus/typeweaver-gen": "^0.9.0"
   },
   "dependencies": {
     "case": "^1.6.3"
   },
   "scripts": {
-    "typecheck": "tsc --noEmit",
+    "typecheck": "tsc --noEmit -p tsconfig.typecheck.json",
     "format": "oxfmt",
     "build": "tsdown && mkdir -p ./dist/templates ./dist/lib && cp -r ./src/templates/* ./dist/templates/ && cp -r ./src/lib/* ./dist/lib/ && cp ../../LICENSE ../../NOTICE ./dist/",
     "test": "vitest --run",