ts-typed-api 0.2.12 → 0.2.14

package/dist/handler.d.ts

@@ -1,12 +1,13 @@
 import { ApiDefinitionSchema } from "./definition";
 import { createRouteHandler } from "./router";
+import { MiddlewareResponse } from "./object-handlers";
 import express from "express";
 export type SpecificRouteHandler<TDef extends ApiDefinitionSchema> = {
     [TDomain_ in keyof TDef['endpoints']]: {
         [TRouteKey_ in keyof TDef['endpoints'][TDomain_]]: ReturnType<typeof createRouteHandler<TDef, TDomain_, TRouteKey_>>;
     }[keyof TDef['endpoints'][TDomain_]];
 }[keyof TDef['endpoints']];
-export type EndpointMiddleware<TDef extends ApiDefinitionSchema = ApiDefinitionSchema> = (req: express.Request, res: express.Response, next: express.NextFunction, endpointInfo: {
+export type EndpointMiddleware<TDef extends ApiDefinitionSchema = ApiDefinitionSchema> = (req: express.Request, res: MiddlewareResponse, next: express.NextFunction, endpointInfo: {
     [TDomain in keyof TDef['endpoints']]: {
         domain: TDomain;
         routeKey: keyof TDef['endpoints'][TDomain];

package/dist/handler.js

@@ -55,6 +55,50 @@ function preprocessQueryParams(query, querySchema) {
     }
     return processedQuery;
 }
+// Helper function to create respond method for middleware compatibility
+function createRespondFunction(routeDefinition, responseSetter) {
+    return (status, data) => {
+        const responseSchema = routeDefinition.responses[status];
+        if (!responseSchema) {
+            console.error(`No response schema defined for status ${status}`);
+            responseSetter(500, {
+                data: null,
+                error: [{ field: "general", type: "general", message: "Internal server error: Undefined response schema for status." }]
+            });
+            return;
+        }
+        let responseBody;
+        if (status === 422) {
+            responseBody = {
+                data: null,
+                error: data
+            };
+        }
+        else {
+            responseBody = {
+                data: data,
+                error: null
+            };
+        }
+        const validationResult = responseSchema.safeParse(responseBody);
+        if (validationResult.success) {
+            // Handle 204 responses specially - they must not have a body
+            if (status === 204) {
+                responseSetter(status, null);
+            }
+            else {
+                responseSetter(status, validationResult.data);
+            }
+        }
+        else {
+            console.error(`FATAL: Constructed response body failed Zod validation for status ${status}.`, validationResult.error.issues, 'Provided data:', data, 'Constructed response body:', responseBody);
+            responseSetter(500, {
+                data: null,
+                error: [{ field: "general", type: "general", message: "Internal server error: Constructed response failed validation." }]
+            });
+        }
+    };
+}
 // Helper function to create multer middleware based on file upload configuration
 function createFileUploadMiddleware(config) {
     // Default multer configuration
@@ -367,7 +411,12 @@ middlewares) {
             middlewares.forEach(middleware => {
                 const wrappedMiddleware = async (req, res, next) => {
                     try {
-                        await middleware(req, res, next, { domain: currentDomain, routeKey: currentRouteKey });
+                        // Add respond method to res for middleware compatibility
+                        const middlewareRes = res;
+                        middlewareRes.respond = createRespondFunction(routeDefinition, (status, data) => {
+                            res.status(status).json(data);
+                        });
+                        await middleware(req, middlewareRes, next, { domain: currentDomain, routeKey: currentRouteKey });
                     }
                     catch (error) {
                         next(error);

package/dist/hono-cloudflare-workers.js

@@ -415,10 +415,70 @@ function registerHonoRouteHandlers(app, apiDefinition, routeHandlers, middleware
                             path: c.req.path,
                             originalUrl: c.req.url
                         };
-                        // Create minimal res object (middleware shouldn't use it)
-                        const fakeRes = {};
+                        // Create minimal res object with respond method for middleware compatibility
+                        const fakeRes = {
+                            respond: (status, data) => {
+                                const responseSchema = routeDefinition.responses[status];
+                                if (!responseSchema) {
+                                    console.error(`No response schema defined for status ${status}`);
+                                    c.json({
+                                        data: null,
+                                        error: [{ field: "general", type: "general", message: "Internal server error: Undefined response schema for status." }]
+                                    }, 500);
+                                    return;
+                                }
+                                let responseBody;
+                                if (status === 422) {
+                                    responseBody = {
+                                        data: null,
+                                        error: data
+                                    };
+                                }
+                                else {
+                                    responseBody = {
+                                        data: data,
+                                        error: null
+                                    };
+                                }
+                                const validationResult = responseSchema.safeParse(responseBody);
+                                if (validationResult.success) {
+                                    // Handle 204 responses specially - they must not have a body
+                                    if (status === 204) {
+                                        c.__response = new Response(null, { status: status });
+                                    }
+                                    else {
+                                        c.__response = c.json(validationResult.data, status);
+                                    }
+                                }
+                                else {
+                                    console.error(`FATAL: Constructed response body failed Zod validation for status ${status}.`, validationResult.error.issues, 'Provided data:', data, 'Constructed response body:', responseBody);
+                                    c.__response = c.json({
+                                        data: null,
+                                        error: [{ field: "general", type: "general", message: "Internal server error: Constructed response failed validation." }]
+                                    }, 500);
+                                }
+                            },
+                            status: (status) => {
+                                // For middleware that might use status, but since not used, stub
+                                c.__response = new Response(null, { status: status });
+                            },
+                            json: (data) => {
+                                // Send json response
+                                c.__response = c.json(data);
+                            },
+                            setHeader: (name, value) => {
+                                c.header(name, value);
+                            },
+                            end: () => {
+                                // Perhaps do nothing or set response
+                            }
+                        };
                         // Call Express-style middleware
                         await middleware(fakeReq, fakeRes, next, { domain: currentDomain, routeKey: currentRouteKey });
+                        // Check if middleware responded directly
+                        if (c.__response) {
+                            return c.__response;
+                        }
                     }
                     catch (error) {
                         console.error('Middleware error:', error);

package/dist/object-handlers.d.ts

@@ -7,15 +7,22 @@ export type EndpointInfo<TDef extends ApiDefinitionSchema = ApiDefinitionSchema>
         routeKey: keyof TDef['endpoints'][TDomain];
     };
 }[keyof TDef['endpoints']];
-export type EndpointMiddleware<TDef extends ApiDefinitionSchema = ApiDefinitionSchema> = (req: express.Request, res: express.Response, next: express.NextFunction, endpointInfo: EndpointInfo<TDef>) => void | Promise<void>;
-export type SimpleMiddleware = (req: express.Request, res: express.Response, next: express.NextFunction) => void | Promise<void>;
-export type UniversalEndpointMiddleware = (req: express.Request, res: express.Response, next: express.NextFunction, endpointInfo: {
+export type EndpointMiddleware<TDef extends ApiDefinitionSchema = ApiDefinitionSchema> = (req: express.Request, res: MiddlewareResponse, next: express.NextFunction, endpointInfo: EndpointInfo<TDef>) => void | Promise<void>;
+export type SimpleMiddleware = (req: express.Request, res: MiddlewareResponse, next: express.NextFunction) => void | Promise<void>;
+export type UniversalEndpointMiddleware = (req: express.Request, res: MiddlewareResponse, next: express.NextFunction, endpointInfo: {
     domain: string;
     routeKey: string;
 }) => void | Promise<void>;
+export interface MiddlewareResponse {
+    respond(status: number, data: any): void;
+    status(code: number): this;
+    json(data: any): void;
+    setHeader(name: string, value: string): void;
+    end(): void;
+}
 export type EndpointMiddlewareCtx<Ctx extends Record<string, any> = Record<string, any>, TDef extends ApiDefinitionSchema = ApiDefinitionSchema> = ((req: express.Request & {
     ctx?: Ctx;
-}, res: express.Response, next: express.NextFunction, endpointInfo: EndpointInfo<TDef>) => void | Promise<void>) | ((c: any, next: any) => void | Promise<void>);
+}, res: MiddlewareResponse, next: express.NextFunction, endpointInfo: EndpointInfo<TDef>) => void | Promise<void>) | ((c: any, next: any) => void | Promise<void>);
 export type AnyMiddleware<TDef extends ApiDefinitionSchema = ApiDefinitionSchema> = EndpointMiddleware<TDef> | UniversalEndpointMiddleware | SimpleMiddleware;
 type HandlerFunction<TDef extends ApiDefinitionSchema, TDomain extends keyof TDef['endpoints'], TRouteKey extends keyof TDef['endpoints'][TDomain], Ctx extends Record<string, any> = Record<string, any>> = (req: TypedRequest<TDef, TDomain, TRouteKey, ApiParams<TDef, TDomain, TRouteKey>, ApiBody<TDef, TDomain, TRouteKey>, ApiQuery<TDef, TDomain, TRouteKey>, Record<string, any>, Ctx>, res: TypedResponse<TDef, TDomain, TRouteKey>) => Promise<void> | void;
 export type ObjectHandlers<TDef extends ApiDefinitionSchema, Ctx extends Record<string, any> = Record<string, any>> = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-typed-api",
-  "version": "0.2.12",
+  "version": "0.2.14",
   "description": "A lightweight, type-safe RPC library for TypeScript with Zod validation",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/handler.ts

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { ApiDefinitionSchema, RouteSchema, UnifiedError, FileUploadConfig } from "./definition";
 import { createRouteHandler, TypedRequest, TypedResponse } from "./router";
+import { MiddlewareResponse } from "./object-handlers";
 import express from "express";
 import multer from "multer";
 
@@ -16,7 +17,7 @@ export type SpecificRouteHandler<TDef extends ApiDefinitionSchema> = {
 // Type for middleware function that receives endpoint information with type safety
 export type EndpointMiddleware<TDef extends ApiDefinitionSchema = ApiDefinitionSchema> = (
     req: express.Request,
-    res: express.Response,
+    res: MiddlewareResponse,
     next: express.NextFunction,
     endpointInfo: {
         [TDomain in keyof TDef['endpoints']]: {
@@ -79,6 +80,61 @@ function preprocessQueryParams(query: any, querySchema?: z.ZodTypeAny): any {
     return processedQuery;
 }
 
+// Helper function to create respond method for middleware compatibility
+function createRespondFunction(
+    routeDefinition: RouteSchema,
+    responseSetter: (status: number, data: any) => void
+) {
+    return (status: number, data: any) => {
+        const responseSchema = routeDefinition.responses[status];
+
+        if (!responseSchema) {
+            console.error(`No response schema defined for status ${status}`);
+            responseSetter(500, {
+                data: null,
+                error: [{ field: "general", type: "general", message: "Internal server error: Undefined response schema for status." }]
+            });
+            return;
+        }
+
+        let responseBody: any;
+
+        if (status === 422) {
+            responseBody = {
+                data: null,
+                error: data
+            };
+        } else {
+            responseBody = {
+                data: data,
+                error: null
+            };
+        }
+
+        const validationResult = responseSchema.safeParse(responseBody);
+
+        if (validationResult.success) {
+            // Handle 204 responses specially - they must not have a body
+            if (status === 204) {
+                responseSetter(status, null);
+            } else {
+                responseSetter(status, validationResult.data);
+            }
+        } else {
+            console.error(
+                `FATAL: Constructed response body failed Zod validation for status ${status}.`,
+                validationResult.error.issues,
+                'Provided data:', data,
+                'Constructed response body:', responseBody
+            );
+            responseSetter(500, {
+                data: null,
+                error: [{ field: "general", type: "general", message: "Internal server error: Constructed response failed validation." }]
+            });
+        }
+    };
+}
+
 // Helper function to create multer middleware based on file upload configuration
 function createFileUploadMiddleware(config: FileUploadConfig): express.RequestHandler {
     // Default multer configuration
@@ -418,7 +474,12 @@ export function registerRouteHandlers<TDef extends ApiDefinitionSchema>(
             middlewares.forEach(middleware => {
                 const wrappedMiddleware: express.RequestHandler = async (req, res, next) => {
                     try {
-                        await middleware(req, res, next, { domain: currentDomain, routeKey: currentRouteKey } as any);
+                        // Add respond method to res for middleware compatibility
+                        const middlewareRes = res as any;
+                        middlewareRes.respond = createRespondFunction(routeDefinition, (status, data) => {
+                            res.status(status).json(data);
+                        });
+                        await middleware(req, middlewareRes as MiddlewareResponse, next, { domain: currentDomain, routeKey: currentRouteKey } as any);
                     } catch (error) {
                         next(error);
                     }

package/src/hono-cloudflare-workers.ts

@@ -497,12 +497,80 @@ export function registerHonoRouteHandlers<
                             originalUrl: c.req.url
                         };
 
-                        // Create minimal res object (middleware shouldn't use it)
-                        const fakeRes = {};
+                        // Create minimal res object with respond method for middleware compatibility
+                        const fakeRes = {
+                            respond: (status: number, data: any) => {
+                                const responseSchema = routeDefinition.responses[status];
+
+                                if (!responseSchema) {
+                                    console.error(`No response schema defined for status ${status}`);
+                                    c.json({
+                                        data: null,
+                                        error: [{ field: "general", type: "general", message: "Internal server error: Undefined response schema for status." }]
+                                    }, 500);
+                                    return;
+                                }
+
+                                let responseBody: any;
+
+                                if (status === 422) {
+                                    responseBody = {
+                                        data: null,
+                                        error: data
+                                    };
+                                } else {
+                                    responseBody = {
+                                        data: data,
+                                        error: null
+                                    };
+                                }
+
+                                const validationResult = responseSchema.safeParse(responseBody);
+
+                                if (validationResult.success) {
+                                    // Handle 204 responses specially - they must not have a body
+                                    if (status === 204) {
+                                        (c as any).__response = new Response(null, { status: status as any });
+                                    } else {
+                                        (c as any).__response = c.json(validationResult.data, status as any);
+                                    }
+                                } else {
+                                    console.error(
+                                        `FATAL: Constructed response body failed Zod validation for status ${status}.`,
+                                        validationResult.error.issues,
+                                        'Provided data:', data,
+                                        'Constructed response body:', responseBody
+                                    );
+                                    (c as any).__response = c.json({
+                                        data: null,
+                                        error: [{ field: "general", type: "general", message: "Internal server error: Constructed response failed validation." }]
+                                    }, 500);
+                                }
+                            },
+                            status: (status: number) => {
+                                // For middleware that might use status, but since not used, stub
+                                (c as any).__response = new Response(null, { status: status });
+                            },
+                            json: (data: any) => {
+                                // Send json response
+                                (c as any).__response = c.json(data);
+                            },
+                            setHeader: (name: string, value: string) => {
+                                c.header(name, value);
+                            },
+                            end: () => {
+                                // Perhaps do nothing or set response
+                            }
+                        };
 
                         // Call Express-style middleware
                         await middleware(fakeReq as any, fakeRes as any, next, { domain: currentDomain, routeKey: currentRouteKey });
 
+                        // Check if middleware responded directly
+                        if ((c as any).__response) {
+                            return (c as any).__response;
+                        }
+
                     } catch (error) {
                         console.error('Middleware error:', error);
                         await next();

package/src/object-handlers.ts

@@ -13,7 +13,7 @@ export type EndpointInfo<TDef extends ApiDefinitionSchema = ApiDefinitionSchema>
 // Type for middleware function that receives endpoint information
 export type EndpointMiddleware<TDef extends ApiDefinitionSchema = ApiDefinitionSchema> = (
     req: express.Request,
-    res: express.Response,
+    res: MiddlewareResponse,
     next: express.NextFunction,
     endpointInfo: EndpointInfo<TDef>
 ) => void | Promise<void>;
@@ -21,14 +21,14 @@ export type EndpointMiddleware<TDef extends ApiDefinitionSchema = ApiDefinitionS
 // Type for simple middleware that doesn't need endpoint information
 export type SimpleMiddleware = (
     req: express.Request,
-    res: express.Response,
+    res: MiddlewareResponse,
     next: express.NextFunction
 ) => void | Promise<void>;
 
 // Type for middleware that can work with any API definition
 export type UniversalEndpointMiddleware = (
     req: express.Request,
-    res: express.Response,
+    res: MiddlewareResponse,
     next: express.NextFunction,
     endpointInfo: {
         domain: string;
@@ -36,13 +36,22 @@ export type UniversalEndpointMiddleware = (
     }
 ) => void | Promise<void>;
 
+// Custom response interface for framework-agnostic middleware
+export interface MiddlewareResponse {
+    respond(status: number, data: any): void;
+    status(code: number): this;
+    json(data: any): void;
+    setHeader(name: string, value: string): void;
+    end(): void;
+}
+
 // Unified middleware type that works for both Express and Hono with context typing
 export type EndpointMiddlewareCtx<
     Ctx extends Record<string, any> = Record<string, any>,
     TDef extends ApiDefinitionSchema = ApiDefinitionSchema
 > =
     // Express version: (req, res, next, endpointInfo)
-    ((req: express.Request & { ctx?: Ctx }, res: express.Response, next: express.NextFunction, endpointInfo: EndpointInfo<TDef>) => void | Promise<void>) |
+    ((req: express.Request & { ctx?: Ctx }, res: MiddlewareResponse, next: express.NextFunction, endpointInfo: EndpointInfo<TDef>) => void | Promise<void>) |
     // Hono version: (c, next) - context is passed via c.req.ctx -> c.ctx copying
     ((c: any, next: any) => void | Promise<void>);
 

package/tests/middleware.test.ts

@@ -58,6 +58,9 @@ describe.each([
                 401: ({ data }) => {
                     throw new Error(`Authentication failed: ${data.error}`);
                 },
+                403: ({ data }) => {
+                    throw new Error(`Forbidden: ${data.error}`);
+                },
                 422: ({ error }) => {
                     throw new Error(`Validation error: ${JSON.stringify(error)}`);
                 }
@@ -74,11 +77,32 @@ describe.each([
                         expect(data.error).toBe('No authorization header');
                         throw new Error('Authentication failed as expected');
                     },
+                    403: ({ data }) => {
+                        throw new Error(`Unexpected forbidden: ${data.error}`);
+                    },
                     422: ({ error }) => {
                         throw new Error(`Validation error: ${JSON.stringify(error)}`);
                     }
                 })
             ).rejects.toThrow('Authentication failed as expected');
         });
+
+        test('should deny access with invalid auth header', async () => {
+            await expect(
+                client.callApi('public', 'protected', { headers: { Authorization: 'Bearer invalid-token' } }, {
+                    200: ({ data }) => data,
+                    401: ({ data }) => {
+                        throw new Error(`Unexpected auth failed: ${data.error}`);
+                    },
+                    403: ({ data }) => {
+                        expect(data.error).toBe('Forbidden');
+                        throw new Error('Forbidden as expected');
+                    },
+                    422: ({ error }) => {
+                        throw new Error(`Validation error: ${JSON.stringify(error)}`);
+                    }
+                })
+            ).rejects.toThrow('Forbidden as expected');
+        });
     });
 });

package/tests/setup.ts

@@ -219,7 +219,8 @@ export const MiddlewareTestApiDefinition = CreateApiDefinition({
                 path: '/protected',
                 responses: CreateResponses({
                     200: z.object({ message: z.string(), user: z.string() }),
-                    401: z.object({ error: z.string() })
+                    401: z.object({ error: z.string() }),
+                    403: z.object({ error: z.string() })
                 })
             },
             context: {
@@ -444,7 +445,74 @@ async function startHonoServer(): Promise<void> {
     });
 }
 
-type Ctx = { user: string }
+type Ctx = { user?: string; noAuth?: boolean; forbidden?: boolean, middlewareData?: string }
+
+// Shared handlers for middleware tests
+const middlewareTestHandlers = {
+    public: {
+        ping: async (req: any, res: any) => {
+            res.respond(200, { message: "pong" });
+        },
+        protected: async (req: any, res: any) => {
+            // Middleware has already validated auth, so we only handle success case
+            res.respond(200, {
+                message: "protected content",
+                user: req.ctx?.user || "unknown"
+            });
+        },
+        context: async (req: any, res: any) => {
+            res.respond(200, {
+                message: "context test",
+                contextData: req.ctx?.middlewareData || "default"
+            });
+        }
+    }
+};
+
+// Generic middleware setup function
+function setupMiddlewareApp(app: any, isHono: boolean) {
+    // Define middleware functions
+    const loggingMiddleware: EndpointMiddlewareCtx<Ctx> = async (req, res, next, endpointInfo) => {
+        console.log(`[Test] ${req.method} ${req.path} - Domain: ${endpointInfo.domain}, Route: ${endpointInfo.routeKey}`);
+        await next();
+    }
+
+    const contextMiddleware: EndpointMiddlewareCtx<Ctx> = async (req, res, next) => {
+        req.ctx = { ...req.ctx, middlewareData: "middleware-added-data" };
+        await next();
+    }
+
+    const authMiddleware: EndpointMiddlewareCtx<Ctx> = async (req, res, next, endpointInfo) => {
+        // Only apply auth checks to protected routes
+        if (endpointInfo.domain === 'public' && endpointInfo.routeKey === 'protected') {
+            const authHeader = req.headers?.authorization;
+            if (!authHeader) {
+                res.respond(401, { error: "No authorization header" });
+            } else if (authHeader === 'Bearer valid-token') {
+                req.ctx = { ...req.ctx, user: 'testuser' };
+                await next();
+            } else {
+                res.respond(403, { error: "Forbidden" });
+            }
+        } else {
+            await next();
+        }
+    }
+
+    const middlewares = [
+        loggingMiddleware,
+        contextMiddleware,
+        authMiddleware
+    ]
+
+    // Register handlers with middleware
+    if (isHono) {
+        const hndl = CreateTypedHonoHandlerWithContext<Ctx>();
+        hndl(app, MiddlewareTestApiDefinition, middlewareTestHandlers, middlewares);
+    } else {
+        RegisterHandlers(app, MiddlewareTestApiDefinition, middlewareTestHandlers, middlewares);
+    }
+}
 
 // Middleware test servers
 async function startMiddlewareExpressServer(): Promise<void> {
@@ -452,54 +520,7 @@ async function startMiddlewareExpressServer(): Promise<void> {
         const app = express();
         app.use(express.json());
 
-        // Define middleware functions
-        const loggingMiddleware = (req: express.Request, res: express.Response, next: express.NextFunction, endpointInfo: any) => {
-            console.log(`[Test] ${req.method} ${req.path} - Domain: ${endpointInfo.domain}, Route: ${endpointInfo.routeKey}`);
-            next();
-        };
-
-        const contextMiddleware = (req: express.Request, res: express.Response, next: express.NextFunction) => {
-            (req as any).ctx = { middlewareData: "middleware-added-data" };
-            next();
-        };
-
-        const authMiddleware: EndpointMiddlewareCtx<Ctx> = (req, res, next) => {
-            const authHeader = req.headers.authorization;
-            if (authHeader === 'Bearer valid-token') {
-                req.ctx = { user: 'testuser' };
-            }
-            next();
-        };
-
-        // Register handlers with middleware
-        RegisterHandlers(app, MiddlewareTestApiDefinition, {
-            public: {
-                ping: async (req: any, res: any) => {
-                    res.respond(200, { message: "pong" });
-                },
-                protected: async (req, res) => {
-                    // Check if user is authenticated via context
-                    if (req.ctx && req.ctx.user) {
-                        res.respond(200, {
-                            message: "protected content",
-                            user: req.ctx.user
-                        });
-                    } else {
-                        res.respond(401, { error: "No authorization header" });
-                    }
-                },
-                context: async (req: any, res: any) => {
-                    res.respond(200, {
-                        message: "context test",
-                        contextData: req.ctx?.middlewareData || "default"
-                    });
-                }
-            }
-        }, [
-            loggingMiddleware,
-            contextMiddleware,
-            authMiddleware
-        ]);
+        setupMiddlewareApp(app, false);
 
         middlewareExpressServer = app.listen(MIDDLEWARE_EXPRESS_PORT, () => {
             resolve();
@@ -511,55 +532,7 @@ async function startMiddlewareHonoServer(): Promise<void> {
     return new Promise((resolve) => {
         const app = new Hono();
 
-        // Define middleware functions
-        const loggingMiddleware = async (req: any, res: any, next: any, endpointInfo: any) => {
-            console.log(`[Test Hono] ${req.method} ${req.path} - Domain: ${endpointInfo.domain}, Route: ${endpointInfo.routeKey}`);
-            await next();
-        };
-
-        const contextMiddleware = async (req: any, res: any, next: any) => {
-            req.ctx = { ...req.ctx, middlewareData: "middleware-added-data" };
-            await next();
-        };
-
-        const authMiddleware: EndpointMiddlewareCtx<Ctx> = async (req, res, next) => {
-            const authHeader = req.headers?.authorization;
-            if (authHeader === 'Bearer valid-token') {
-                req.ctx = { ...req.ctx, user: 'testuser' };
-            }
-            await next();
-        };
-
-        const hdnl = CreateTypedHonoHandlerWithContext<Ctx>()
-        // Register handlers with middleware
-        hdnl(app, MiddlewareTestApiDefinition, {
-            public: {
-                ping: async (req: any, res: any) => {
-                    res.respond(200, { message: "pong" });
-                },
-                protected: async (req, res) => {
-                    // Check if user is authenticated via context
-                    if (req.ctx && req.ctx.user) {
-                        res.respond(200, {
-                            message: "protected content",
-                            user: req.ctx.user
-                        });
-                    } else {
-                        res.respond(401, { error: "No authorization header" });
-                    }
-                },
-                context: async (req: any, res: any) => {
-                    res.respond(200, {
-                        message: "context test",
-                        contextData: req.ctx?.middlewareData || "default"
-                    });
-                }
-            }
-        }, [
-            loggingMiddleware,
-            contextMiddleware,
-            authMiddleware
-        ]);
+        setupMiddlewareApp(app, true);
 
         // Create HTTP server from Hono app
         const server = app.fetch;