ts-typed-api 0.2.13 → 0.2.15

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

@@ -302,7 +302,7 @@ middlewares) {
                     baseUrl: expressReq.baseUrl,
                     url: expressReq.url,
                 };
-                // Augment expressRes with the .respond method, using TDef
+                // Augment expressRes with the .respond and .setHeader methods, using TDef
                 const typedExpressRes = expressRes;
                 typedExpressRes.respond = (status, dataForResponse) => {
                     // Use the passed apiDefinition object
@@ -347,6 +347,11 @@ middlewares) {
                         });
                     }
                 };
+                typedExpressRes.setHeader = (name, value) => {
+                    // Call the original Express setHeader method to avoid recursion
+                    Object.getPrototypeOf(expressRes).setHeader.call(expressRes, name, value);
+                    return typedExpressRes;
+                };
                 const specificHandlerFn = handler;
                 await specificHandlerFn(finalTypedReq, typedExpressRes);
             }
@@ -412,10 +417,11 @@ middlewares) {
                 const wrappedMiddleware = async (req, res, next) => {
                     try {
                         // Add respond method to res for middleware compatibility
-                        res.respond = createRespondFunction(routeDefinition, (status, data) => {
+                        const middlewareRes = res;
+                        middlewareRes.respond = createRespondFunction(routeDefinition, (status, data) => {
                             res.status(status).json(data);
                         });
-                        await middleware(req, res, next, { domain: currentDomain, routeKey: currentRouteKey });
+                        await middleware(req, middlewareRes, next, { domain: currentDomain, routeKey: currentRouteKey });
                     }
                     catch (error) {
                         next(error);

package/dist/hono-cloudflare-workers.js

@@ -329,7 +329,11 @@ function registerHonoRouteHandlers(app, apiDefinition, routeHandlers, middleware
                     originalUrl: c.req.url
                 };
                 const fakeRes = {
-                    respond: c.respond
+                    respond: c.respond,
+                    setHeader: (name, value) => {
+                        c.header(name, value);
+                        return fakeRes;
+                    }
                 };
                 const specificHandlerFn = handler;
                 await specificHandlerFn(fakeReq, fakeRes);
@@ -457,6 +461,20 @@ function registerHonoRouteHandlers(app, apiDefinition, routeHandlers, middleware
                                         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

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/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>;
+    setHeader: (name: string, value: string) => this;
     json: <B = any>(body: B) => this;
 }
 export declare function createRouteHandler<TDef extends ApiDefinitionSchema, TDomain extends keyof TDef['endpoints'], TRouteKey extends keyof TDef['endpoints'][TDomain], // Using direct keyof for simplicity

package/examples/simple/definitions.ts

@@ -34,6 +34,15 @@ export const PublicApiDefinition = CreateApiDefinition({
                     200: z.enum(["pong"]),
                 })
             },
+            customHeaders: {
+                method: 'GET',
+                path: '/custom-headers',
+                responses: CreateResponses({
+                    200: z.object({
+                        message: z.string()
+                    }),
+                })
+            },
         }
     }
 })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-typed-api",
-  "version": "0.2.13",
+  "version": "0.2.15",
   "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']]: {
@@ -354,7 +355,7 @@ export function registerRouteHandlers<TDef extends ApiDefinitionSchema>(
                     url: expressReq.url,
                 } as TypedRequest<TDef, typeof currentDomain, typeof currentRouteKey>;
 
-                // Augment expressRes with the .respond method, using TDef
+                // Augment expressRes with the .respond and .setHeader methods, using TDef
                 const typedExpressRes = expressRes as TypedResponse<TDef, typeof currentDomain, typeof currentRouteKey>;
 
                 typedExpressRes.respond = (status, dataForResponse) => {
@@ -407,6 +408,12 @@ export function registerRouteHandlers<TDef extends ApiDefinitionSchema>(
                     }
                 };
 
+                typedExpressRes.setHeader = (name: string, value: string) => {
+                    // Call the original Express setHeader method to avoid recursion
+                    Object.getPrototypeOf(expressRes).setHeader.call(expressRes, name, value);
+                    return typedExpressRes;
+                };
+
                 const specificHandlerFn = handler as (
                     req: TypedRequest<TDef, typeof currentDomain, typeof currentRouteKey>,
                     res: TypedResponse<TDef, typeof currentDomain, typeof currentRouteKey>
@@ -474,10 +481,11 @@ export function registerRouteHandlers<TDef extends ApiDefinitionSchema>(
                 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) => {
+                        const middlewareRes = res as any;
+                        middlewareRes.respond = createRespondFunction(routeDefinition, (status, data) => {
                             res.status(status).json(data);
                         });
-                        await middleware(req, res, next, { domain: currentDomain, routeKey: currentRouteKey } as any);
+                        await middleware(req, middlewareRes as MiddlewareResponse, next, { domain: currentDomain, routeKey: currentRouteKey } as any);
                     } catch (error) {
                         next(error);
                     }

package/src/hono-cloudflare-workers.ts

@@ -407,7 +407,11 @@ export function registerHonoRouteHandlers<
                 } as TypedRequest<TDef, typeof currentDomain, typeof currentRouteKey>;
 
                 const fakeRes = {
-                    respond: (c as any).respond
+                    respond: (c as any).respond,
+                    setHeader: (name: string, value: string) => {
+                        c.header(name, value);
+                        return fakeRes;
+                    }
                 } as TypedResponse<TDef, typeof currentDomain, typeof currentRouteKey>;
 
                 const specificHandlerFn = handler as (
@@ -546,6 +550,20 @@ export function registerHonoRouteHandlers<
                                         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
                             }
                         };
 

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/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>;
+    setHeader: (name: string, value: string) => this;
     json: <B = any>(body: B) => this; // Keep original json
 }
 

package/tests/setup.ts

@@ -7,12 +7,18 @@ 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 = {
     common: {
         ping: async (req: any, res: any) => {
             res.respond(200, "pong");
+        },
+        customHeaders: async (req: any, res: any) => {
+            res.setHeader('X-Custom-Test', 'test-value');
+            res.setHeader('X-Another-Header', 'another-value');
+            res.respond(200, { message: "headers set" });
         }
     },
     status: {
@@ -444,7 +450,7 @@ async function startHonoServer(): Promise<void> {
     });
 }
 
-type Ctx = { user?: string; noAuth?: boolean; forbidden?: boolean }
+type Ctx = { user?: string; noAuth?: boolean; forbidden?: boolean, middlewareData?: string }
 
 // Shared handlers for middleware tests
 const middlewareTestHandlers = {
@@ -471,74 +477,45 @@ const middlewareTestHandlers = {
 // 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 = 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 = 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 {
+    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();
-            }
-        } :
-        (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();
+                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, [
-            loggingMiddleware,
-            contextMiddleware,
-            authMiddleware
-        ]);
+        hndl(app, MiddlewareTestApiDefinition, middlewareTestHandlers, middlewares);
     } else {
-        RegisterHandlers(app, MiddlewareTestApiDefinition, middlewareTestHandlers, [
-            loggingMiddleware,
-            contextMiddleware,
-            authMiddleware
-        ]);
+        RegisterHandlers(app, MiddlewareTestApiDefinition, middlewareTestHandlers, middlewares);
     }
 }
 

package/tests/simple-api.test.ts

@@ -74,6 +74,39 @@ describe.each([
 
             expect(result).toBe('pong');
         });
+
+        test('should set response headers', async () => {
+            // Direct HTTP call to test header setting
+            const response = await fetch(`${baseUrl}/api/v1/public/ping`);
+            const contentType = response.headers.get('content-type');
+
+            // Check that standard headers are set
+            if (serverName === 'Express') {
+                expect(contentType).toBe('application/json; charset=utf-8');
+            } else {
+                // Hono sets content-type differently
+                expect(contentType).toBe('application/json');
+            }
+            expect(response.status).toBe(200);
+        });
+
+        test('should set custom headers', async () => {
+            // Direct HTTP call to test custom header setting
+            const response = await fetch(`${baseUrl}/api/v1/public/custom-headers`);
+            const data = await response.json();
+
+            // Check response data (unified response format)
+            expect(data.data).toEqual({ message: "headers set" });
+            expect(data).not.toHaveProperty('error'); // Error should not be present for success responses
+            expect(response.status).toBe(200);
+
+            // Check custom headers
+            const customHeader = response.headers.get('x-custom-test');
+            const anotherHeader = response.headers.get('x-another-header');
+
+            expect(customHeader).toBe('test-value');
+            expect(anotherHeader).toBe('another-value');
+        });
     });
 
     describe('Private API', () => {