ts-typed-api 0.2.13 → 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

@@ -412,10 +412,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

@@ -457,6 +457,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-typed-api",
-  "version": "0.2.13",
+  "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']]: {
@@ -474,10 +475,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

@@ -546,6 +546,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/tests/setup.ts

@@ -7,6 +7,7 @@ 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 = {
@@ -444,7 +445,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 +472,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);
     }
 }