ts-typed-api 0.2.12 → 0.2.13

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,6 +411,10 @@ middlewares) {
             middlewares.forEach(middleware => {
                 const wrappedMiddleware = async (req, res, next) => {
                     try {
+                        // Add respond method to res for middleware compatibility
+                        res.respond = createRespondFunction(routeDefinition, (status, data) => {
+                            res.status(status).json(data);
+                        });
                         await middleware(req, res, next, { domain: currentDomain, routeKey: currentRouteKey });
                     }
                     catch (error) {

package/dist/hono-cloudflare-workers.js

@@ -415,10 +415,56 @@ 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);
+                                }
+                            }
+                        };
                         // 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-typed-api",
-  "version": "0.2.12",
+  "version": "0.2.13",
   "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

@@ -79,6 +79,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,6 +473,10 @@ export function registerRouteHandlers<TDef extends ApiDefinitionSchema>(
             middlewares.forEach(middleware => {
                 const wrappedMiddleware: express.RequestHandler = async (req, res, next) => {
                     try {
+                        // Add respond method to res for middleware compatibility
+                        (res as any).respond = createRespondFunction(routeDefinition, (status, data) => {
+                            res.status(status).json(data);
+                        });
                         await middleware(req, res, next, { domain: currentDomain, routeKey: currentRouteKey } as any);
                     } catch (error) {
                         next(error);

package/src/hono-cloudflare-workers.ts

@@ -497,12 +497,66 @@ 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);
+                                }
+                            }
+                        };
 
                         // 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/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

@@ -7,7 +7,6 @@ import { PublicApiDefinition as SimplePublicApiDefinition, PrivateApiDefinition
 import { PublicApiDefinition as AdvancedPublicApiDefinition, PrivateApiDefinition as AdvancedPrivateApiDefinition } from '../examples/advanced/definitions';
 import { RegisterHandlers, RegisterHonoHandlers, CreateApiDefinition, CreateResponses, CreateTypedHonoHandlerWithContext } from '../src';
 import { z } from 'zod';
-import { EndpointMiddlewareCtx } from '../src/object-handlers';
 
 // Shared handler definitions for simple API
 const simplePublicHandlers = {
@@ -219,7 +218,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,62 +444,111 @@ async function startHonoServer(): Promise<void> {
     });
 }
 
-type Ctx = { user: string }
+type Ctx = { user?: string; noAuth?: boolean; forbidden?: boolean }
 
-// Middleware test servers
-async function startMiddlewareExpressServer(): Promise<void> {
-    return new Promise((resolve) => {
-        const app = express();
-        app.use(express.json());
+// 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"
+            });
+        }
+    }
+};
 
-        // Define middleware functions
-        const loggingMiddleware = (req: express.Request, res: express.Response, next: express.NextFunction, endpointInfo: any) => {
+// Generic middleware setup function
+function setupMiddlewareApp(app: any, isHono: boolean) {
+    // Define middleware functions
+    const loggingMiddleware = isHono ?
+        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();
+        } :
+        (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) => {
+    const contextMiddleware = isHono ?
+        async (req: any, res: any, next: any) => {
+            req.ctx = { ...req.ctx, middlewareData: "middleware-added-data" };
+            await next();
+        } :
+        (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' };
+    const authMiddleware = isHono ?
+        async (req: any, res: any, next: any, endpointInfo: any) => {
+            // Only apply auth checks to protected routes
+            if (endpointInfo.domain === 'public' && endpointInfo.routeKey === 'protected') {
+                const authHeader = req.headers?.authorization;
+                if (!authHeader) {
+                    (res as any).respond(401, { error: "No authorization header" });
+                } else if (authHeader === 'Bearer valid-token') {
+                    req.ctx = { ...req.ctx, user: 'testuser' };
+                    await next();
+                } else {
+                    (res as any).respond(403, { error: "Forbidden" });
+                }
+            } else {
+                await next();
             }
-            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"
-                    });
+        } :
+        (req: any, res: any, next: any, endpointInfo: any) => {
+            // Only apply auth checks to protected routes
+            if (endpointInfo.domain === 'public' && endpointInfo.routeKey === 'protected') {
+                const authHeader = req.headers?.authorization;
+                if (!authHeader) {
+                    (res as any).respond(401, { error: "No authorization header" });
+                } else if (authHeader === 'Bearer valid-token') {
+                    req.ctx = { ...req.ctx, user: 'testuser' };
+                    next();
+                } else {
+                    (res as any).respond(403, { error: "Forbidden" });
                 }
+            } else {
+                next();
             }
-        }, [
+        };
+
+    // Register handlers with middleware
+    if (isHono) {
+        const hndl = CreateTypedHonoHandlerWithContext<Ctx>();
+        hndl(app, MiddlewareTestApiDefinition, middlewareTestHandlers, [
+            loggingMiddleware,
+            contextMiddleware,
+            authMiddleware
+        ]);
+    } else {
+        RegisterHandlers(app, MiddlewareTestApiDefinition, middlewareTestHandlers, [
             loggingMiddleware,
             contextMiddleware,
             authMiddleware
         ]);
+    }
+}
+
+// Middleware test servers
+async function startMiddlewareExpressServer(): Promise<void> {
+    return new Promise((resolve) => {
+        const app = express();
+        app.use(express.json());
+
+        setupMiddlewareApp(app, false);
 
         middlewareExpressServer = app.listen(MIDDLEWARE_EXPRESS_PORT, () => {
             resolve();
@@ -511,55 +560,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;