ts-typed-api 0.2.16 → 0.2.18

package/dist/handler.js

@@ -56,8 +56,19 @@ function preprocessQueryParams(query, querySchema) {
     return processedQuery;
 }
 // Helper function to create respond method for middleware compatibility
-function createRespondFunction(routeDefinition, responseSetter) {
+function createRespondFunction(routeDefinition, responseSetter, middlewareRes) {
     return (status, data) => {
+        // Call any registered response callbacks
+        if (middlewareRes && middlewareRes._responseCallbacks) {
+            middlewareRes._responseCallbacks.forEach((callback) => {
+                try {
+                    callback(status, data);
+                }
+                catch (error) {
+                    console.error('Error in response callback:', error);
+                }
+            });
+        }
         const responseSchema = routeDefinition.responses[status];
         if (!responseSchema) {
             console.error(`No response schema defined for status ${status}`);
@@ -305,6 +316,17 @@ middlewares) {
                 // Augment expressRes with the .respond and .setHeader methods, using TDef
                 const typedExpressRes = expressRes;
                 typedExpressRes.respond = (status, dataForResponse) => {
+                    // Call any registered response callbacks from middleware
+                    if (expressRes._responseCallbacks) {
+                        expressRes._responseCallbacks.forEach((callback) => {
+                            try {
+                                callback(status, dataForResponse);
+                            }
+                            catch (error) {
+                                console.error('Error in response callback:', error);
+                            }
+                        });
+                    }
                     // Use the passed apiDefinition object
                     const routeSchemaForHandler = apiDefinition.endpoints[currentDomain][currentRouteKey];
                     const responseSchemaForStatus = routeSchemaForHandler.responses[status];
@@ -347,6 +369,12 @@ middlewares) {
                         });
                     }
                 };
+                typedExpressRes.respondContentType = (status, data, contentType) => {
+                    // Set the content type header
+                    typedExpressRes.setHeader('Content-Type', contentType);
+                    // Send the raw data without JSON wrapping or validation
+                    typedExpressRes.status(status).send(data);
+                };
                 typedExpressRes.setHeader = (name, value) => {
                     // Call the original Express setHeader method to avoid recursion
                     Object.getPrototypeOf(expressRes).setHeader.call(expressRes, name, value);
@@ -416,11 +444,18 @@ middlewares) {
             middlewares.forEach(middleware => {
                 const wrappedMiddleware = async (req, res, next) => {
                     try {
-                        // Add respond method to res for middleware compatibility
+                        // Add respond and onFinish methods to res for middleware compatibility
                         const middlewareRes = res;
                         middlewareRes.respond = createRespondFunction(routeDefinition, (status, data) => {
                             res.status(status).json(data);
-                        });
+                        }, middlewareRes);
+                        middlewareRes.onResponse = (callback) => {
+                            // Store callback on the underlying express response so it's accessible from TypedResponse
+                            if (!res._responseCallbacks) {
+                                res._responseCallbacks = [];
+                            }
+                            res._responseCallbacks.push(callback);
+                        };
                         await middleware(req, middlewareRes, next, { domain: currentDomain, routeKey: currentRouteKey });
                     }
                     catch (error) {

package/dist/hono-cloudflare-workers.js

@@ -273,6 +273,17 @@ function registerHonoRouteHandlers(app, apiDefinition, routeHandlers, middleware
                 c.ctx = c.get('ctx') || {};
                 // Add respond method to context
                 c.respond = (status, data) => {
+                    // Call any registered response callbacks from middleware
+                    if (c._responseCallbacks) {
+                        c._responseCallbacks.forEach((callback) => {
+                            try {
+                                callback(status, data);
+                            }
+                            catch (error) {
+                                console.error('Error in response callback:', error);
+                            }
+                        });
+                    }
                     const responseSchema = routeDefinition.responses[status];
                     if (!responseSchema) {
                         console.error(`No response schema defined for status ${status} in route ${String(currentDomain)}/${String(currentRouteKey)}`);
@@ -330,6 +341,13 @@ function registerHonoRouteHandlers(app, apiDefinition, routeHandlers, middleware
                 };
                 const fakeRes = {
                     respond: c.respond,
+                    respondContentType: (status, data, contentType) => {
+                        // For Hono, set the response directly
+                        c.__response = new Response(data, {
+                            status: status,
+                            headers: { 'Content-Type': contentType }
+                        });
+                    },
                     setHeader: (name, value) => {
                         c.header(name, value);
                         return fakeRes;
@@ -419,9 +437,20 @@ function registerHonoRouteHandlers(app, apiDefinition, routeHandlers, middleware
                             path: c.req.path,
                             originalUrl: c.req.url
                         };
-                        // Create minimal res object with respond method for middleware compatibility
+                        // Create minimal res object with respond and onResponse methods for middleware compatibility
                         const fakeRes = {
                             respond: (status, data) => {
+                                // Call any registered response callbacks
+                                if (c._responseCallbacks) {
+                                    c._responseCallbacks.forEach((callback) => {
+                                        try {
+                                            callback(status, data);
+                                        }
+                                        catch (error) {
+                                            console.error('Error in response callback:', error);
+                                        }
+                                    });
+                                }
                                 const responseSchema = routeDefinition.responses[status];
                                 if (!responseSchema) {
                                     console.error(`No response schema defined for status ${status}`);
@@ -475,6 +504,13 @@ function registerHonoRouteHandlers(app, apiDefinition, routeHandlers, middleware
                             },
                             end: () => {
                                 // Perhaps do nothing or set response
+                            },
+                            onResponse: (callback) => {
+                                // Store callback to be called when respond() is invoked
+                                if (!c._responseCallbacks) {
+                                    c._responseCallbacks = [];
+                                }
+                                c._responseCallbacks.push(callback);
                             }
                         };
                         // Call Express-style middleware

package/dist/index.d.ts

@@ -2,7 +2,7 @@ export { ApiClient, FetchHttpClientAdapter } from './client';
 export { generateOpenApiSpec } from './openapi';
 export { generateOpenApiSpec as generateOpenApiSpec2 } from './openapi-self';
 export { CreateApiDefinition, CreateResponses, ApiDefinitionSchema } from './definition';
-export { RegisterHandlers, EndpointMiddleware, UniversalEndpointMiddleware, SimpleMiddleware, EndpointInfo } from './object-handlers';
+export { RegisterHandlers, EndpointMiddleware, UniversalEndpointMiddleware, SimpleMiddleware, EndpointInfo, MiddlewareResponse } from './object-handlers';
 export { File as UploadedFile } from './router';
 export { z as ZodSchema } from 'zod';
 export { RegisterHonoHandlers, registerHonoRouteHandlers, HonoFile, HonoFileType, honoFileSchema, HonoTypedContext, CreateTypedHonoHandlerWithContext } from './hono-cloudflare-workers';

package/dist/object-handlers.d.ts

@@ -19,6 +19,7 @@ export interface MiddlewareResponse {
     json(data: any): void;
     setHeader(name: string, value: string): void;
     end(): void;
+    onResponse(callback: (status: number, data: any) => void): void;
 }
 export type EndpointMiddlewareCtx<Ctx extends Record<string, any> = Record<string, any>, TDef extends ApiDefinitionSchema = ApiDefinitionSchema> = ((req: express.Request & {
     ctx?: Ctx;

package/dist/router.d.ts

@@ -14,6 +14,7 @@ type ResponseDataForStatus<TDef extends ApiDefinitionSchema, TDomain extends key
 type RespondFunction<TDef extends ApiDefinitionSchema, TDomain extends keyof TDef['endpoints'], TRouteName extends keyof TDef['endpoints'][TDomain]> = <TStatusLocal extends keyof TDef['endpoints'][TDomain][TRouteName]['responses'] & number>(status: TStatusLocal, data: ResponseDataForStatus<TDef, TDomain, TRouteName, TStatusLocal>) => void;
 export interface TypedResponse<TDef extends ApiDefinitionSchema, TDomain extends keyof TDef['endpoints'], TRouteName extends keyof TDef['endpoints'][TDomain], L extends Record<string, any> = Record<string, any>> extends express.Response<any, L> {
     respond: RespondFunction<TDef, TDomain, TRouteName>;
+    respondContentType: (status: number, data: any, contentType: string) => void;
     setHeader: (name: string, value: string) => this;
     json: <B = any>(body: B) => this;
 }

package/examples/simple/definitions.ts

@@ -30,6 +30,9 @@ export const PublicApiDefinition = CreateApiDefinition({
             ping: {
                 method: 'GET',
                 path: '/ping',
+                query: z.object({
+                    format: z.enum(["json", "html"]).optional()
+                }),
                 responses: CreateResponses({
                     200: z.enum(["pong"]),
                 })

package/examples/simple/server.ts

@@ -1,6 +1,6 @@
 import express from 'express';
 import { PrivateApiDefinition, PublicApiDefinition } from './definitions';
-import { RegisterHandlers, EndpointMiddleware, createTypedHandler } from '../../src';
+import { RegisterHandlers, EndpointMiddleware } from '../../src';
 const app = express();
 const port = 3001;
 app.set('etag', false);
@@ -39,7 +39,16 @@ RegisterHandlers(app, PublicApiDefinition, {
         // TypeScript will give you type errors if this handler is missing
         ping: async (req, res) => {
             // req and res are fully typed based on the API definition
-            res.respond(200, "pong");
+            if (req.query.format === 'html') {
+                res.respondContentType(200, "<h1>pong</h1>", "text/html");
+            } else {
+                res.respond(200, "pong");
+            }
+        },
+        customHeaders: async (req, res) => {
+            res.setHeader('x-custom-test', 'test-value');
+            res.setHeader('x-another-header', 'another-value');
+            res.respond(200, { message: "headers set" });
         }
     },
     status: {
@@ -59,10 +68,10 @@ RegisterHandlers(app, PublicApiDefinition, {
 // Add another api definition
 RegisterHandlers(app, PrivateApiDefinition, {
     user: {
-        get: createTypedHandler(async (req, res) => {
+        get: async (req, res) => {
             console.log('Fetching user', req.params.id);
             res.respond(200, "ok");
-        })
+        }
     }
 }, [loggingMiddlewareTyped, authMiddleware]);
 

package/package.json

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

@@ -83,9 +83,21 @@ function preprocessQueryParams(query: any, querySchema?: z.ZodTypeAny): any {
 // Helper function to create respond method for middleware compatibility
 function createRespondFunction(
     routeDefinition: RouteSchema,
-    responseSetter: (status: number, data: any) => void
+    responseSetter: (status: number, data: any) => void,
+    middlewareRes?: any
 ) {
     return (status: number, data: any) => {
+        // Call any registered response callbacks
+        if (middlewareRes && middlewareRes._responseCallbacks) {
+            middlewareRes._responseCallbacks.forEach((callback: (status: number, data: any) => void) => {
+                try {
+                    callback(status, data);
+                } catch (error) {
+                    console.error('Error in response callback:', error);
+                }
+            });
+        }
+
         const responseSchema = routeDefinition.responses[status];
 
         if (!responseSchema) {
@@ -359,6 +371,17 @@ export function registerRouteHandlers<TDef extends ApiDefinitionSchema>(
                 const typedExpressRes = expressRes as TypedResponse<TDef, typeof currentDomain, typeof currentRouteKey>;
 
                 typedExpressRes.respond = (status, dataForResponse) => {
+                    // Call any registered response callbacks from middleware
+                    if ((expressRes as any)._responseCallbacks) {
+                        (expressRes as any)._responseCallbacks.forEach((callback: (status: number, data: any) => void) => {
+                            try {
+                                callback(status, dataForResponse);
+                            } catch (error) {
+                                console.error('Error in response callback:', error);
+                            }
+                        });
+                    }
+
                     // Use the passed apiDefinition object
                     const routeSchemaForHandler = apiDefinition.endpoints[currentDomain][currentRouteKey] as RouteSchema;
                     const responseSchemaForStatus = routeSchemaForHandler.responses[status as number];
@@ -408,6 +431,13 @@ export function registerRouteHandlers<TDef extends ApiDefinitionSchema>(
                     }
                 };
 
+                typedExpressRes.respondContentType = (status: number, data: any, contentType: string) => {
+                    // Set the content type header
+                    typedExpressRes.setHeader('Content-Type', contentType);
+                    // Send the raw data without JSON wrapping or validation
+                    typedExpressRes.status(status).send(data);
+                };
+
                 typedExpressRes.setHeader = (name: string, value: string) => {
                     // Call the original Express setHeader method to avoid recursion
                     Object.getPrototypeOf(expressRes).setHeader.call(expressRes, name, value);
@@ -480,11 +510,18 @@ 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
+                        // Add respond and onFinish methods to res for middleware compatibility
                         const middlewareRes = res as any;
                         middlewareRes.respond = createRespondFunction(routeDefinition, (status, data) => {
                             res.status(status).json(data);
-                        });
+                        }, middlewareRes);
+                        middlewareRes.onResponse = (callback: (status: number, data: any) => void) => {
+                            // Store callback on the underlying express response so it's accessible from TypedResponse
+                            if (!(res as any)._responseCallbacks) {
+                                (res as any)._responseCallbacks = [];
+                            }
+                            (res as any)._responseCallbacks.push(callback);
+                        };
                         await middleware(req, middlewareRes as MiddlewareResponse, next, { domain: currentDomain, routeKey: currentRouteKey } as any);
                     } catch (error) {
                         next(error);

package/src/hono-cloudflare-workers.ts

@@ -341,6 +341,17 @@ export function registerHonoRouteHandlers<
 
                 // Add respond method to context
                 (c as any).respond = (status: number, data: any) => {
+                    // Call any registered response callbacks from middleware
+                    if ((c as any)._responseCallbacks) {
+                        (c as any)._responseCallbacks.forEach((callback: (status: number, data: any) => void) => {
+                            try {
+                                callback(status, data);
+                            } catch (error) {
+                                console.error('Error in response callback:', error);
+                            }
+                        });
+                    }
+
                     const responseSchema = routeDefinition.responses[status];
 
                     if (!responseSchema) {
@@ -408,6 +419,13 @@ export function registerHonoRouteHandlers<
 
                 const fakeRes = {
                     respond: (c as any).respond,
+                    respondContentType: (status: number, data: any, contentType: string) => {
+                        // For Hono, set the response directly
+                        (c as any).__response = new Response(data, {
+                            status: status,
+                            headers: { 'Content-Type': contentType }
+                        });
+                    },
                     setHeader: (name: string, value: string) => {
                         c.header(name, value);
                         return fakeRes;
@@ -501,9 +519,20 @@ export function registerHonoRouteHandlers<
                             originalUrl: c.req.url
                         };
 
-                        // Create minimal res object with respond method for middleware compatibility
+                        // Create minimal res object with respond and onResponse methods for middleware compatibility
                         const fakeRes = {
                             respond: (status: number, data: any) => {
+                                // Call any registered response callbacks
+                                if ((c as any)._responseCallbacks) {
+                                    (c as any)._responseCallbacks.forEach((callback: (status: number, data: any) => void) => {
+                                        try {
+                                            callback(status, data);
+                                        } catch (error) {
+                                            console.error('Error in response callback:', error);
+                                        }
+                                    });
+                                }
+
                                 const responseSchema = routeDefinition.responses[status];
 
                                 if (!responseSchema) {
@@ -564,6 +593,13 @@ export function registerHonoRouteHandlers<
                             },
                             end: () => {
                                 // Perhaps do nothing or set response
+                            },
+                            onResponse: (callback: (status: number, data: any) => void) => {
+                                // Store callback to be called when respond() is invoked
+                                if (!(c as any)._responseCallbacks) {
+                                    (c as any)._responseCallbacks = [];
+                                }
+                                (c as any)._responseCallbacks.push(callback);
                             }
                         };
 

package/src/index.ts

@@ -2,7 +2,7 @@ export { ApiClient, FetchHttpClientAdapter } from './client';
 export { generateOpenApiSpec } from './openapi'
 export { generateOpenApiSpec as generateOpenApiSpec2 } from './openapi-self'
 export { CreateApiDefinition, CreateResponses, ApiDefinitionSchema } from './definition';
-export { RegisterHandlers, EndpointMiddleware, UniversalEndpointMiddleware, SimpleMiddleware, EndpointInfo } from './object-handlers';
+export { RegisterHandlers, EndpointMiddleware, UniversalEndpointMiddleware, SimpleMiddleware, EndpointInfo, MiddlewareResponse } from './object-handlers';
 export { File as UploadedFile } from './router';
 export { z as ZodSchema } from 'zod';
 

package/src/object-handlers.ts

@@ -43,6 +43,7 @@ export interface MiddlewareResponse {
     json(data: any): void;
     setHeader(name: string, value: string): void;
     end(): void;
+    onResponse(callback: (status: number, data: any) => void): void;
 }
 
 // Unified middleware type that works for both Express and Hono with context typing

package/src/router.ts

@@ -59,6 +59,7 @@ export interface TypedResponse<
     L extends Record<string, any> = Record<string, any>
 > extends express.Response<any, L> {
     respond: RespondFunction<TDef, TDomain, TRouteName>;
+    respondContentType: (status: number, data: any, contentType: string) => void;
     setHeader: (name: string, value: string) => this;
     json: <B = any>(body: B) => this; // Keep original json
 }

package/tests/middleware.test.ts

@@ -105,4 +105,81 @@ describe.each([
             ).rejects.toThrow('Forbidden as expected');
         });
     });
+
+    describe('Response Logging Middleware', () => {
+        let consoleSpy: jest.SpyInstance;
+
+        beforeEach(() => {
+            consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+        });
+
+        afterEach(() => {
+            consoleSpy.mockRestore();
+        });
+
+        test('should log response status without breaking functionality', async () => {
+            // The response logging middleware should not interfere with normal operation
+            const result = await client.callApi('public', 'ping', {}, {
+                200: ({ data }) => {
+                    expect(data.message).toBe('pong');
+                    return data;
+                },
+                422: ({ error }) => {
+                    throw new Error(`Validation error: ${JSON.stringify(error)}`);
+                }
+            });
+
+            expect(result.message).toBe('pong');
+
+            // Assert that console.log was called with the expected message
+            expect(consoleSpy).toHaveBeenCalledWith('[TIMING] public.ping responded with 200');
+            expect(consoleSpy).toHaveBeenCalledWith('[Test] GET /api/v1/ping - Domain: public, Route: ping');
+        });
+
+        test('should log response status for protected routes', async () => {
+            const result = await client.callApi('public', 'protected', { headers: { Authorization: 'Bearer valid-token' } }, {
+                200: ({ data }) => {
+                    expect(data.message).toBe('protected content');
+                    expect(data.user).toBe('testuser');
+                    return data;
+                },
+                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)}`);
+                }
+            });
+
+            expect(result.user).toBe('testuser');
+
+            // Assert that console.log was called with the expected messages
+            expect(consoleSpy).toHaveBeenCalledWith('[TIMING] public.protected responded with 200');
+            expect(consoleSpy).toHaveBeenCalledWith('[Test] GET /api/v1/protected - Domain: public, Route: protected');
+        });
+
+        test('should log error status codes for auth failures', async () => {
+            await expect(
+                client.callApi('public', 'protected', {}, {
+                    200: ({ data }) => data,
+                    401: ({ data }) => {
+                        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');
+
+            // Assert that console.log was called with the error status
+            expect(consoleSpy).toHaveBeenCalledWith('[TIMING] public.protected responded with 401');
+        });
+    });
 });

package/tests/setup.ts

@@ -13,7 +13,11 @@ import { EndpointMiddlewareCtx } from '../src/object-handlers';
 const simplePublicHandlers = {
     common: {
         ping: async (req: any, res: any) => {
-            res.respond(200, "pong");
+            if (req.query?.format === 'html') {
+                res.respondContentType(200, "<h1>pong</h1>", "text/html");
+            } else {
+                res.respond(200, "pong");
+            }
         },
         customHeaders: async (req: any, res: any) => {
             res.setHeader('X-Custom-Test', 'test-value');
@@ -477,6 +481,14 @@ const middlewareTestHandlers = {
 // Generic middleware setup function
 function setupMiddlewareApp(app: any, isHono: boolean) {
     // Define middleware functions
+    const timingMiddleware: EndpointMiddlewareCtx<Ctx> = async (req, res, next, endpointInfo) => {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        res.onResponse((status, _data) => {
+            console.log(`[TIMING] ${endpointInfo.domain}.${endpointInfo.routeKey} responded with ${status}`);
+        });
+        await next();
+    };
+
     const loggingMiddleware: EndpointMiddlewareCtx<Ctx> = async (req, res, next, endpointInfo) => {
         console.log(`[Test] ${req.method} ${req.path} - Domain: ${endpointInfo.domain}, Route: ${endpointInfo.routeKey}`);
         await next();
@@ -505,6 +517,7 @@ function setupMiddlewareApp(app: any, isHono: boolean) {
     }
 
     const middlewares = [
+        timingMiddleware,
         loggingMiddleware,
         contextMiddleware,
         authMiddleware

package/tests/simple-api.test.ts

@@ -27,6 +27,19 @@ describe.each([
             expect(result).toBe('pong');
         });
 
+        test('should ping successfully with HTML format', async () => {
+            const response = await fetch(`${baseUrl}/api/v1/public/ping?format=html`);
+            expect(response.status).toBe(200);
+            const contentType = response.headers.get('content-type');
+            if (serverName === 'Express') {
+                expect(contentType).toBe('text/html; charset=utf-8');
+            } else {
+                expect(contentType).toBe('text/html');
+            }
+            const html = await response.text();
+            expect(html).toBe('<h1>pong</h1>');
+        });
+
         test('should handle probe1 with match=true', async () => {
             const result = await client.callApi('status', 'probe1', {
                 query: { match: true }