ts-typed-api 0.2.1 → 0.2.2

package/dist/handler.js

@@ -241,6 +241,7 @@ middlewares) {
                     params: parsedParams,
                     query: parsedQuery,
                     body: parsedBody,
+                    ctx: expressReq.ctx,
                     headers: expressReq.headers,
                     cookies: expressReq.cookies,
                     ip: expressReq.ip,

package/dist/hono-cloudflare-workers.d.ts

@@ -1,4 +1,4 @@
-import { Hono, Context } from 'hono';
+import { Hono, Context, Env } from 'hono';
 import { z } from 'zod';
 import { ApiDefinitionSchema } from './definition';
 import { TypedRequest, TypedResponse } from './router';
@@ -19,7 +19,7 @@ export declare const honoFileSchema: z.ZodObject<{
     stream: z.ZodOptional<z.ZodAny>;
 }, z.core.$strip>;
 export type HonoFileType = z.infer<typeof honoFileSchema>;
-export type HonoTypedContext<TDef extends ApiDefinitionSchema, TDomain extends keyof TDef['endpoints'], TRouteKey extends keyof TDef['endpoints'][TDomain]> = Context & {
+export type HonoTypedContext<TDef extends ApiDefinitionSchema, TDomain extends keyof TDef['endpoints'], TRouteKey extends keyof TDef['endpoints'][TDomain], Ctx extends Record<string, any> = Record<string, any>> = Context & {
     params: TypedRequest<TDef, TDomain, TRouteKey>['params'];
     query: TypedRequest<TDef, TDomain, TRouteKey>['query'];
     body: TypedRequest<TDef, TDomain, TRouteKey>['body'];
@@ -27,7 +27,9 @@ export type HonoTypedContext<TDef extends ApiDefinitionSchema, TDomain extends k
     files?: HonoFile[] | {
         [fieldname: string]: HonoFile[];
     };
+    ctx?: Ctx;
     respond: TypedResponse<TDef, TDomain, TRouteKey>['respond'];
 };
-export declare function registerHonoRouteHandlers<TDef extends ApiDefinitionSchema>(app: Hono, apiDefinition: TDef, routeHandlers: Array<SpecificRouteHandler<TDef>>, middlewares?: EndpointMiddleware<TDef>[]): void;
-export declare function RegisterHonoHandlers<TDef extends ApiDefinitionSchema>(app: Hono, apiDefinition: TDef, objectHandlers: ObjectHandlers<TDef>, middlewares?: AnyMiddleware<TDef>[]): void;
+export declare function registerHonoRouteHandlers<TDef extends ApiDefinitionSchema, TBindings extends Env = Env, TVariables extends Record<string, never> = Record<string, never>, TPath extends string = "/">(app: Hono<TBindings, TVariables, TPath>, apiDefinition: TDef, routeHandlers: Array<SpecificRouteHandler<TDef>>, middlewares?: EndpointMiddleware<TDef>[]): void;
+export declare function RegisterHonoHandlers<TDef extends ApiDefinitionSchema, Ctx extends Record<string, any> = Record<string, any>, TBindings extends Env = Env, TVariables extends Record<string, never> = Record<string, never>, TPath extends string = "/">(app: Hono<TBindings, TVariables, TPath>, apiDefinition: TDef, objectHandlers: ObjectHandlers<TDef, Ctx>, middlewares?: AnyMiddleware<TDef>[]): void;
+export declare function CreateTypedHonoHandlerWithContext<Ctx extends Record<string, any>>(): <TDef extends ApiDefinitionSchema>(app: Hono, apiDefinition: TDef, objectHandlers: ObjectHandlers<TDef, Ctx>, middlewares?: AnyMiddleware<TDef>[]) => void;

package/dist/hono-cloudflare-workers.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.honoFileSchema = void 0;
 exports.registerHonoRouteHandlers = registerHonoRouteHandlers;
 exports.RegisterHonoHandlers = RegisterHonoHandlers;
+exports.CreateTypedHonoHandlerWithContext = CreateTypedHonoHandlerWithContext;
 const zod_1 = require("zod");
 // Hono-compatible file schema for Workers environment
 exports.honoFileSchema = zod_1.z.object({
@@ -268,6 +269,8 @@ function registerHonoRouteHandlers(app, apiDefinition, routeHandlers, middleware
                 c.params = parsedParams;
                 c.query = parsedQuery;
                 c.body = parsedBody;
+                // Get context from Hono's context system
+                c.ctx = c.get('ctx') || {};
                 // Add respond method to context
                 c.respond = (status, data) => {
                     const responseSchema = routeDefinition.responses[status];
@@ -318,6 +321,7 @@ function registerHonoRouteHandlers(app, apiDefinition, routeHandlers, middleware
                     body: parsedBody,
                     file: c.file,
                     files: c.files,
+                    ctx: c.ctx,
                     headers: c.req.header(),
                     ip: c.req.header('CF-Connecting-IP') || '127.0.0.1',
                     method: c.req.method,
@@ -402,11 +406,23 @@ function registerHonoRouteHandlers(app, apiDefinition, routeHandlers, middleware
             middlewares.forEach(middleware => {
                 const wrappedMiddleware = async (c, next) => {
                     try {
-                        await middleware(c.req, c.res, next, { domain: currentDomain, routeKey: currentRouteKey });
+                        // Create Express-like req object for middleware compatibility
+                        const fakeReq = {
+                            headers: c.req.header(),
+                            get ctx() { return c.get('ctx') || {}; },
+                            set ctx(value) { c.set('ctx', value); },
+                            method: c.req.method,
+                            path: c.req.path,
+                            originalUrl: c.req.url
+                        };
+                        // Create minimal res object (middleware shouldn't use it)
+                        const fakeRes = {};
+                        // Call Express-style middleware
+                        await middleware(fakeReq, fakeRes, next, { domain: currentDomain, routeKey: currentRouteKey });
                     }
                     catch (error) {
                         console.error('Middleware error:', error);
-                        return next();
+                        await next();
                     }
                 };
                 middlewareWrappers.push(wrappedMiddleware);
@@ -472,3 +488,8 @@ function RegisterHonoHandlers(app, apiDefinition, objectHandlers, middlewares) {
     }) || [];
     registerHonoRouteHandlers(app, apiDefinition, handlerArray, endpointMiddlewares);
 }
+function CreateTypedHonoHandlerWithContext() {
+    return function (app, apiDefinition, objectHandlers, middlewares) {
+        return RegisterHonoHandlers(app, apiDefinition, objectHandlers, middlewares);
+    };
+}

package/dist/hono-only.d.ts

@@ -1,6 +1,6 @@
 export { CreateApiDefinition, CreateResponses } from './definition';
 export { z as ZodSchema } from 'zod';
 export { EndpointMiddleware } from './object-handlers';
-export { RegisterHonoHandlers } from './hono-cloudflare-workers';
+export { RegisterHonoHandlers, CreateTypedHonoHandlerWithContext } from './hono-cloudflare-workers';
 export type { ApiDefinitionSchema, RouteSchema, UnifiedError, FileUploadConfig, HttpSuccessStatusCode, HttpClientErrorStatusCode, HttpServerErrorStatusCode, AllowedInputStatusCode, AllowedResponseStatusCode } from './definition';
 export type { HonoFile, HonoFileType, HonoTypedContext } from './hono-cloudflare-workers';

package/dist/hono-only.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RegisterHonoHandlers = exports.ZodSchema = exports.CreateResponses = exports.CreateApiDefinition = void 0;
+exports.CreateTypedHonoHandlerWithContext = exports.RegisterHonoHandlers = exports.ZodSchema = exports.CreateResponses = exports.CreateApiDefinition = void 0;
 // Hono-only exports - for Cloudflare Workers and other Hono environments
 // Excludes Express dependencies like multer, busboy, etc.
 var definition_1 = require("./definition");
@@ -11,3 +11,4 @@ Object.defineProperty(exports, "ZodSchema", { enumerable: true, get: function ()
 // Hono adapter for Cloudflare Workers
 var hono_cloudflare_workers_1 = require("./hono-cloudflare-workers");
 Object.defineProperty(exports, "RegisterHonoHandlers", { enumerable: true, get: function () { return hono_cloudflare_workers_1.RegisterHonoHandlers; } });
+Object.defineProperty(exports, "CreateTypedHonoHandlerWithContext", { enumerable: true, get: function () { return hono_cloudflare_workers_1.CreateTypedHonoHandlerWithContext; } });

package/dist/index.d.ts

@@ -5,4 +5,4 @@ export { CreateApiDefinition, CreateResponses, ApiDefinitionSchema } from './def
 export { RegisterHandlers, EndpointMiddleware, UniversalEndpointMiddleware, SimpleMiddleware, EndpointInfo } from './object-handlers';
 export { File as UploadedFile } from './router';
 export { z as ZodSchema } from 'zod';
-export { RegisterHonoHandlers, registerHonoRouteHandlers, HonoFile, HonoFileType, honoFileSchema, HonoTypedContext } from './hono-cloudflare-workers';
+export { RegisterHonoHandlers, registerHonoRouteHandlers, HonoFile, HonoFileType, honoFileSchema, HonoTypedContext, CreateTypedHonoHandlerWithContext } from './hono-cloudflare-workers';

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.honoFileSchema = exports.registerHonoRouteHandlers = exports.RegisterHonoHandlers = exports.ZodSchema = exports.RegisterHandlers = exports.CreateResponses = exports.CreateApiDefinition = exports.generateOpenApiSpec2 = exports.generateOpenApiSpec = exports.FetchHttpClientAdapter = exports.ApiClient = void 0;
+exports.CreateTypedHonoHandlerWithContext = exports.honoFileSchema = exports.registerHonoRouteHandlers = exports.RegisterHonoHandlers = exports.ZodSchema = exports.RegisterHandlers = exports.CreateResponses = exports.CreateApiDefinition = exports.generateOpenApiSpec2 = exports.generateOpenApiSpec = exports.FetchHttpClientAdapter = exports.ApiClient = void 0;
 var client_1 = require("./client");
 Object.defineProperty(exports, "ApiClient", { enumerable: true, get: function () { return client_1.ApiClient; } });
 Object.defineProperty(exports, "FetchHttpClientAdapter", { enumerable: true, get: function () { return client_1.FetchHttpClientAdapter; } });
@@ -20,3 +20,4 @@ var hono_cloudflare_workers_1 = require("./hono-cloudflare-workers");
 Object.defineProperty(exports, "RegisterHonoHandlers", { enumerable: true, get: function () { return hono_cloudflare_workers_1.RegisterHonoHandlers; } });
 Object.defineProperty(exports, "registerHonoRouteHandlers", { enumerable: true, get: function () { return hono_cloudflare_workers_1.registerHonoRouteHandlers; } });
 Object.defineProperty(exports, "honoFileSchema", { enumerable: true, get: function () { return hono_cloudflare_workers_1.honoFileSchema; } });
+Object.defineProperty(exports, "CreateTypedHonoHandlerWithContext", { enumerable: true, get: function () { return hono_cloudflare_workers_1.CreateTypedHonoHandlerWithContext; } });

package/dist/object-handlers.d.ts

@@ -13,13 +13,16 @@ export type UniversalEndpointMiddleware = (req: express.Request, res: express.Re
     domain: string;
     routeKey: string;
 }) => void | Promise<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>);
 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]> = (req: TypedRequest<TDef, TDomain, TRouteKey>, res: TypedResponse<TDef, TDomain, TRouteKey>) => Promise<void> | void;
-export type ObjectHandlers<TDef extends ApiDefinitionSchema> = {
+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, any, any, any, any, Ctx>, res: TypedResponse<TDef, TDomain, TRouteKey>) => Promise<void> | void;
+export type ObjectHandlers<TDef extends ApiDefinitionSchema, Ctx extends Record<string, any> = Record<string, any>> = {
     [TDomain in keyof TDef['endpoints']]: {
-        [TRouteKey in keyof TDef['endpoints'][TDomain]]: HandlerFunction<TDef, TDomain, TRouteKey>;
+        [TRouteKey in keyof TDef['endpoints'][TDomain]]: HandlerFunction<TDef, TDomain, TRouteKey, Ctx>;
     };
 };
-export declare function RegisterHandlers<TDef extends ApiDefinitionSchema>(app: express.Express, apiDefinition: TDef, objectHandlers: ObjectHandlers<TDef>, middlewares?: AnyMiddleware<TDef>[]): void;
+export declare function RegisterHandlers<TDef extends ApiDefinitionSchema, Ctx extends Record<string, any> = Record<string, any>>(app: express.Express, apiDefinition: TDef, objectHandlers: ObjectHandlers<TDef, Ctx>, middlewares?: AnyMiddleware<TDef>[]): void;
 export declare function makeObjectHandlerRegistrar<TDef extends ApiDefinitionSchema>(apiDefinition: TDef): (app: express.Express, objectHandlers: ObjectHandlers<TDef>, middlewares?: EndpointMiddleware<TDef>[]) => void;
 export {};

package/dist/router.d.ts

@@ -3,11 +3,12 @@ import { ApiDefinitionSchema, // Changed from ApiDefinition
 ApiBody, ApiParams, ApiQuery, InferDataFromUnifiedResponse } from './definition';
 export type File = Express.Multer.File;
 export type TypedRequest<TDef extends ApiDefinitionSchema, TDomain extends keyof TDef['endpoints'], TRouteKey extends keyof TDef['endpoints'][TDomain], // Using direct keyof for simplicity here
-P extends ApiParams<TDef, TDomain, TRouteKey> = ApiParams<TDef, TDomain, TRouteKey>, ReqBody extends ApiBody<TDef, TDomain, TRouteKey> = ApiBody<TDef, TDomain, TRouteKey>, Q extends ApiQuery<TDef, TDomain, TRouteKey> = ApiQuery<TDef, TDomain, TRouteKey>, L extends Record<string, any> = Record<string, any>> = express.Request<P, any, ReqBody, Q, L> & {
+P extends ApiParams<TDef, TDomain, TRouteKey> = ApiParams<TDef, TDomain, TRouteKey>, ReqBody extends ApiBody<TDef, TDomain, TRouteKey> = ApiBody<TDef, TDomain, TRouteKey>, Q extends ApiQuery<TDef, TDomain, TRouteKey> = ApiQuery<TDef, TDomain, TRouteKey>, L extends Record<string, any> = Record<string, any>, Ctx extends Record<string, any> = Record<string, any>> = express.Request<P, any, ReqBody, Q, L> & {
     file?: File;
     files?: File[] | {
         [fieldname: string]: File[];
     };
+    ctx?: Ctx;
 };
 type ResponseDataForStatus<TDef extends ApiDefinitionSchema, TDomain extends keyof TDef['endpoints'], TRouteName extends keyof TDef['endpoints'][TDomain], TStatus extends keyof TDef['endpoints'][TDomain][TRouteName]['responses'] & number> = InferDataFromUnifiedResponse<TDef['endpoints'][TDomain][TRouteName]['responses'][TStatus]>;
 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;
@@ -15,10 +16,11 @@ export interface TypedResponse<TDef extends ApiDefinitionSchema, TDomain extends
     respond: RespondFunction<TDef, TDomain, TRouteName>;
     json: <B = any>(body: B) => this;
 }
-export declare function createRouteHandler<TDef extends ApiDefinitionSchema, TDomain extends keyof TDef['endpoints'], TRouteKey extends keyof TDef['endpoints'][TDomain]>(domain: TDomain, routeKey: TRouteKey, handler: (req: TypedRequest<TDef, TDomain, TRouteKey>, res: TypedResponse<TDef, TDomain, TRouteKey>) => Promise<void> | void): {
+export declare function createRouteHandler<TDef extends ApiDefinitionSchema, TDomain extends keyof TDef['endpoints'], TRouteKey extends keyof TDef['endpoints'][TDomain], // Using direct keyof for simplicity
+Ctx extends Record<string, any> = Record<string, any>>(domain: TDomain, routeKey: TRouteKey, handler: (req: TypedRequest<TDef, TDomain, TRouteKey, any, any, any, any, Ctx>, res: TypedResponse<TDef, TDomain, TRouteKey>) => Promise<void> | void): {
     domain: TDomain;
     routeKey: TRouteKey;
-    handler: (req: TypedRequest<TDef, TDomain, TRouteKey>, res: TypedResponse<TDef, TDomain, TRouteKey>) => Promise<void> | void;
+    handler: (req: TypedRequest<TDef, TDomain, TRouteKey, any, any, any, any, Ctx>, res: TypedResponse<TDef, TDomain, TRouteKey>) => Promise<void> | void;
 };
 export declare function makeRouteHandlerCreator<TDef extends ApiDefinitionSchema>(): <TDomain extends keyof TDef["endpoints"], TRouteKey extends keyof TDef["endpoints"][TDomain]>(domain: TDomain, routeKey: TRouteKey, handler: (req: TypedRequest<TDef, TDomain, TRouteKey>, res: TypedResponse<TDef, TDomain, TRouteKey>) => Promise<void> | void) => ReturnType<typeof createRouteHandler<TDef, TDomain, TRouteKey>>;
 export {};

package/dist/router.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createRouteHandler = createRouteHandler;
 exports.makeRouteHandlerCreator = makeRouteHandlerCreator;
-// Type-safe route handler creation function, now generic over TDef
+// Type-safe route handler creation function, now generic over TDef and Ctx
 // This function is called within a context where TDef is known (e.g. specific handlers file)
 function createRouteHandler(domain, routeKey, handler) {
     // The returned object includes enough type information (domain, routeKey)

package/examples/simple/server.ts

@@ -18,7 +18,7 @@ const loggingMiddlewareTyped: EndpointMiddleware<typeof PrivateApiDefinition> =
 };
 
 // Universal auth middleware that doesn't use endpointInfo
-const authMiddleware = async (req, res, next) => {
+const authMiddleware: EndpointMiddleware = async (req, res, next) => {
     // Example auth logic
     const authHeader = req.headers.authorization;
     if (!authHeader || !authHeader.startsWith('Bearer ')) {

package/examples/test-hono-server.ts

@@ -1,7 +1,8 @@
 import { Hono } from 'hono';
 import http from 'http';
-import { PublicApiDefinition as SimplePublicApiDefinition, PrivateApiDefinition as SimplePrivateApiDefinition } from './examples/simple/definitions';
-import { RegisterHonoHandlers } from './src';
+import { PublicApiDefinition as SimplePublicApiDefinition, PrivateApiDefinition as SimplePrivateApiDefinition } from './simple/definitions';
+import { CreateTypedHonoHandlerWithContext, RegisterHonoHandlers } from '../src';
+import { EndpointMiddlewareCtx } from '../src/object-handlers';
 
 const HONO_PORT = 3004;
 
@@ -12,11 +13,18 @@ async function startHonoServer() {
 
     console.log('Registering handlers...');
 
+    type Ctx = { foo: string, blah: () => string }
+
+    const loggingMiddleware: EndpointMiddlewareCtx<Ctx> = (req, res, next, endpointInfo) => {
+        console.log(`[${new Date().toISOString()}] ${req.method} ${req.path} - Endpoint: ${endpointInfo.domain}.${endpointInfo.routeKey}`);
+        next();
+    };
+
+    const registerWithContext = CreateTypedHonoHandlerWithContext<Ctx>()
     // Register public handlers using Hono
-    RegisterHonoHandlers(app, SimplePublicApiDefinition, {
+    registerWithContext(app, SimplePublicApiDefinition, {
         common: {
             ping: async (req, res) => {
-                console.log('Handling ping request');
                 res.respond(200, "pong");
             }
         },
@@ -33,7 +41,7 @@ async function startHonoServer() {
                 res.respond(200, "pong");
             }
         }
-    });
+    }, [loggingMiddleware]);
 
     // Register private handlers using Hono
     RegisterHonoHandlers(app, SimplePrivateApiDefinition, {
@@ -52,19 +60,15 @@ async function startHonoServer() {
 
     // Create a simple HTTP server wrapper for Hono
     const honoServer = http.createServer(async (req: any, res: any) => {
-        console.log(`Incoming request: ${req.method} ${req.url}`);
-
         try {
             // Read the request body for non-GET/HEAD methods
             let body: ReadableStream | undefined;
             if (req.method !== 'GET' && req.method !== 'HEAD') {
-                console.log('Reading request body...');
                 const chunks: Buffer[] = [];
                 for await (const chunk of req) {
                     chunks.push(chunk);
                 }
                 const buffer = Buffer.concat(chunks);
-                console.log('Request body length:', buffer.length);
                 body = new ReadableStream({
                     start(controller) {
                         controller.enqueue(buffer);
@@ -73,18 +77,12 @@ async function startHonoServer() {
                 });
             }
 
-            console.log('Creating Web API Request...');
-            const request = new Request(`http://localhost:${HONO_PORT}${req.url}`, {
+            const response = await server(new Request(`http://localhost:${HONO_PORT}${req.url}`, {
                 method: req.method,
                 headers: req.headers,
-                body: body
-            });
-
-            console.log('Calling Hono app.fetch...');
-            const response = await server(request);
-
-            console.log('Response status:', response.status);
-            console.log('Response headers:', Object.fromEntries(response.headers.entries()));
+                body: body,
+                duplex: body ? 'half' : undefined
+            } as any));
 
             res.statusCode = response.status;
             for (const [key, value] of response.headers) {
@@ -92,10 +90,8 @@ async function startHonoServer() {
             }
 
             const responseBody = await response.text();
-            console.log('Response body:', responseBody);
             res.end(responseBody);
         } catch (error) {
-            console.error('Hono server error:', error);
             res.statusCode = 500;
             res.end('Internal Server Error');
         }
@@ -115,10 +111,7 @@ async function startHonoServer() {
     // Graceful shutdown
     process.on('SIGINT', () => {
         console.log('Shutting down server...');
-        honoServer.close(() => {
-            console.log('Server closed');
-            process.exit(0);
-        });
+        process.exit(0);
     });
 }
 

package/package.json

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

@@ -281,6 +281,7 @@ export function registerRouteHandlers<TDef extends ApiDefinitionSchema>(
                     params: parsedParams,
                     query: parsedQuery,
                     body: parsedBody,
+                    ctx: (expressReq as any).ctx,
                     headers: expressReq.headers,
                     cookies: expressReq.cookies,
                     ip: expressReq.ip,

package/src/hono-cloudflare-workers.ts

@@ -1,4 +1,4 @@
-import { Hono, Context, MiddlewareHandler } from 'hono';
+import { Hono, Context, MiddlewareHandler, Env } from 'hono';
 import { z } from 'zod';
 import { ApiDefinitionSchema, RouteSchema, UnifiedError, FileUploadConfig } from './definition';
 import { TypedRequest, TypedResponse } from './router';
@@ -29,7 +29,8 @@ export type HonoFileType = z.infer<typeof honoFileSchema>;
 export type HonoTypedContext<
     TDef extends ApiDefinitionSchema,
     TDomain extends keyof TDef['endpoints'],
-    TRouteKey extends keyof TDef['endpoints'][TDomain]
+    TRouteKey extends keyof TDef['endpoints'][TDomain],
+    Ctx extends Record<string, any> = Record<string, any>
 > = Context & {
     // Add typed request properties
     params: TypedRequest<TDef, TDomain, TRouteKey>['params'];
@@ -37,6 +38,8 @@ export type HonoTypedContext<
     body: TypedRequest<TDef, TDomain, TRouteKey>['body'];
     file?: HonoFile;
     files?: HonoFile[] | { [fieldname: string]: HonoFile[] };
+    // Add typed context object
+    ctx?: Ctx;
 
     // Add typed response method
     respond: TypedResponse<TDef, TDomain, TRouteKey>['respond'];
@@ -265,8 +268,13 @@ function createHonoFileUploadMiddleware(config: FileUploadConfig): MiddlewareHan
 }
 
 // Register route handlers with Hono, now generic over TDef
-export function registerHonoRouteHandlers<TDef extends ApiDefinitionSchema>(
-    app: Hono,
+export function registerHonoRouteHandlers<
+    TDef extends ApiDefinitionSchema,
+    TBindings extends Env = Env,
+    TVariables extends Record<string, never> = Record<string, never>,
+    TPath extends string = "/"
+>(
+    app: Hono<TBindings, TVariables, TPath>,
     apiDefinition: TDef,
     routeHandlers: Array<SpecificRouteHandler<TDef>>,
     middlewares?: EndpointMiddleware<TDef>[]
@@ -328,6 +336,9 @@ export function registerHonoRouteHandlers<TDef extends ApiDefinitionSchema>(
                 (c as any).query = parsedQuery;
                 (c as any).body = parsedBody;
 
+                // Get context from Hono's context system
+                (c as any).ctx = c.get('ctx') || {};
+
                 // Add respond method to context
                 (c as any).respond = (status: number, data: any) => {
                     const responseSchema = routeDefinition.responses[status];
@@ -387,6 +398,7 @@ export function registerHonoRouteHandlers<TDef extends ApiDefinitionSchema>(
                     body: parsedBody,
                     file: (c as any).file,
                     files: (c as any).files,
+                    ctx: (c as any).ctx,
                     headers: c.req.header(),
                     ip: c.req.header('CF-Connecting-IP') || '127.0.0.1',
                     method: c.req.method,
@@ -475,10 +487,25 @@ export function registerHonoRouteHandlers<TDef extends ApiDefinitionSchema>(
             middlewares.forEach(middleware => {
                 const wrappedMiddleware: MiddlewareHandler = async (c: any, next: any) => {
                     try {
-                        await middleware(c.req as any, c.res as any, next, { domain: currentDomain, routeKey: currentRouteKey } as any);
+                        // Create Express-like req object for middleware compatibility
+                        const fakeReq = {
+                            headers: c.req.header(),
+                            get ctx() { return c.get('ctx') || {}; },
+                            set ctx(value) { c.set('ctx', value); },
+                            method: c.req.method,
+                            path: c.req.path,
+                            originalUrl: c.req.url
+                        };
+
+                        // Create minimal res object (middleware shouldn't use it)
+                        const fakeRes = {};
+
+                        // Call Express-style middleware
+                        await middleware(fakeReq as any, fakeRes as any, next, { domain: currentDomain, routeKey: currentRouteKey });
+
                     } catch (error) {
                         console.error('Middleware error:', error);
-                        return next();
+                        await next();
                     }
                 };
                 middlewareWrappers.push(wrappedMiddleware);
@@ -502,8 +529,11 @@ export function registerHonoRouteHandlers<TDef extends ApiDefinitionSchema>(
 }
 
 // Transform object-based handlers to array format
-function transformObjectHandlersToArray<TDef extends ApiDefinitionSchema>(
-    objectHandlers: ObjectHandlers<TDef>
+function transformObjectHandlersToArray<
+    TDef extends ApiDefinitionSchema,
+    Ctx extends Record<string, any> = Record<string, any>
+>(
+    objectHandlers: ObjectHandlers<TDef, Ctx>
 ): Array<SpecificRouteHandler<TDef>> {
     const handlerArray: Array<SpecificRouteHandler<TDef>> = [];
 
@@ -529,10 +559,16 @@ function transformObjectHandlersToArray<TDef extends ApiDefinitionSchema>(
 }
 
 // Main utility function that registers object-based handlers with Hono
-export function RegisterHonoHandlers<TDef extends ApiDefinitionSchema>(
-    app: Hono,
+export function RegisterHonoHandlers<
+    TDef extends ApiDefinitionSchema,
+    Ctx extends Record<string, any> = Record<string, any>,
+    TBindings extends Env = Env,
+    TVariables extends Record<string, never> = Record<string, never>,
+    TPath extends string = "/"
+>(
+    app: Hono<TBindings, TVariables, TPath>,
     apiDefinition: TDef,
-    objectHandlers: ObjectHandlers<TDef>,
+    objectHandlers: ObjectHandlers<TDef, Ctx>,
     middlewares?: AnyMiddleware<TDef>[]
 ): void {
     const handlerArray = transformObjectHandlersToArray(objectHandlers);
@@ -550,3 +586,14 @@ export function RegisterHonoHandlers<TDef extends ApiDefinitionSchema>(
 
     registerHonoRouteHandlers(app, apiDefinition, handlerArray, endpointMiddlewares);
 }
+
+export function CreateTypedHonoHandlerWithContext<Ctx extends Record<string, any>>() {
+    return function <TDef extends ApiDefinitionSchema>(
+        app: Hono,
+        apiDefinition: TDef,
+        objectHandlers: ObjectHandlers<TDef, Ctx>,
+        middlewares?: AnyMiddleware<TDef>[]
+    ) {
+        return RegisterHonoHandlers(app, apiDefinition, objectHandlers, middlewares);
+    };
+}

package/src/hono-only.ts

@@ -5,7 +5,7 @@ export { z as ZodSchema } from 'zod';
 export { EndpointMiddleware } from './object-handlers'
 
 // Hono adapter for Cloudflare Workers
-export { RegisterHonoHandlers } from './hono-cloudflare-workers';
+export { RegisterHonoHandlers, CreateTypedHonoHandlerWithContext } from './hono-cloudflare-workers';
 
 // Re-export types that are needed for Hono development
 export type {

package/src/index.ts

@@ -7,4 +7,4 @@ export { File as UploadedFile } from './router';
 export { z as ZodSchema } from 'zod';
 
 // Hono adapter for Cloudflare Workers
-export { RegisterHonoHandlers, registerHonoRouteHandlers, HonoFile, HonoFileType, honoFileSchema, HonoTypedContext } from './hono-cloudflare-workers';
+export { RegisterHonoHandlers, registerHonoRouteHandlers, HonoFile, HonoFileType, honoFileSchema, HonoTypedContext, CreateTypedHonoHandlerWithContext } from './hono-cloudflare-workers';

package/src/object-handlers.ts

@@ -36,6 +36,16 @@ export type UniversalEndpointMiddleware = (
     }
 ) => void | Promise<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>) |
+    // Hono version: (c, next) - context is passed via c.req.ctx -> c.ctx copying
+    ((c: any, next: any) => void | Promise<void>);
+
 // Union type that accepts endpoint-aware, universal, and simple middleware
 export type AnyMiddleware<TDef extends ApiDefinitionSchema = ApiDefinitionSchema> =
     | EndpointMiddleware<TDef>
@@ -46,23 +56,30 @@ export type AnyMiddleware<TDef extends ApiDefinitionSchema = ApiDefinitionSchema
 type HandlerFunction<
     TDef extends ApiDefinitionSchema,
     TDomain extends keyof TDef['endpoints'],
-    TRouteKey extends keyof TDef['endpoints'][TDomain]
+    TRouteKey extends keyof TDef['endpoints'][TDomain],
+    Ctx extends Record<string, any> = Record<string, any>
 > = (
-    req: TypedRequest<TDef, TDomain, TRouteKey>,
+    req: TypedRequest<TDef, TDomain, TRouteKey, any, any, any, any, Ctx>,
     res: TypedResponse<TDef, TDomain, TRouteKey>
 ) => Promise<void> | void;
 
 // Type for the object-based handler definition
 // This ensures all domains and routes are required
-export type ObjectHandlers<TDef extends ApiDefinitionSchema> = {
-    [TDomain in keyof TDef['endpoints']]: {
-        [TRouteKey in keyof TDef['endpoints'][TDomain]]: HandlerFunction<TDef, TDomain, TRouteKey>;
+export type ObjectHandlers<
+    TDef extends ApiDefinitionSchema,
+    Ctx extends Record<string, any> = Record<string, any>
+> = {
+        [TDomain in keyof TDef['endpoints']]: {
+            [TRouteKey in keyof TDef['endpoints'][TDomain]]: HandlerFunction<TDef, TDomain, TRouteKey, Ctx>;
+        };
     };
-};
 
 // Transform object-based handlers to array format
-function transformObjectHandlersToArray<TDef extends ApiDefinitionSchema>(
-    objectHandlers: ObjectHandlers<TDef>
+function transformObjectHandlersToArray<
+    TDef extends ApiDefinitionSchema,
+    Ctx extends Record<string, any> = Record<string, any>
+>(
+    objectHandlers: ObjectHandlers<TDef, Ctx>
 ): Array<SpecificRouteHandler<TDef>> {
     const handlerArray: Array<SpecificRouteHandler<TDef>> = [];
 
@@ -91,10 +108,13 @@ function transformObjectHandlersToArray<TDef extends ApiDefinitionSchema>(
 }
 
 // Main utility function that registers object-based handlers
-export function RegisterHandlers<TDef extends ApiDefinitionSchema>(
+export function RegisterHandlers<
+    TDef extends ApiDefinitionSchema,
+    Ctx extends Record<string, any> = Record<string, any>
+>(
     app: express.Express,
     apiDefinition: TDef,
-    objectHandlers: ObjectHandlers<TDef>,
+    objectHandlers: ObjectHandlers<TDef, Ctx>,
     middlewares?: AnyMiddleware<TDef>[]
 ): void {
     const handlerArray = transformObjectHandlersToArray(objectHandlers);

package/src/router.ts

@@ -19,11 +19,14 @@ export type TypedRequest<
     P extends ApiParams<TDef, TDomain, TRouteKey> = ApiParams<TDef, TDomain, TRouteKey>,
     ReqBody extends ApiBody<TDef, TDomain, TRouteKey> = ApiBody<TDef, TDomain, TRouteKey>,
     Q extends ApiQuery<TDef, TDomain, TRouteKey> = ApiQuery<TDef, TDomain, TRouteKey>,
-    L extends Record<string, any> = Record<string, any>
+    L extends Record<string, any> = Record<string, any>,
+    Ctx extends Record<string, any> = Record<string, any>
 > = express.Request<P, any, ReqBody, Q, L> & {
     // Add file upload support
     file?: File;
     files?: File[] | { [fieldname: string]: File[] };
+    // Add typed context object for carrying data between middlewares and handlers
+    ctx?: Ctx;
 }
 
 // --- Enhanced TypedResponse with res.respond, now generic over TDef ---
@@ -59,18 +62,19 @@ export interface TypedResponse<
     json: <B = any>(body: B) => this; // Keep original json
 }
 
-// Type-safe route handler creation function, now generic over TDef
+// Type-safe route handler creation function, now generic over TDef and Ctx
 // This function is called within a context where TDef is known (e.g. specific handlers file)
 export function createRouteHandler<
     TDef extends ApiDefinitionSchema,
     TDomain extends keyof TDef['endpoints'],
-    TRouteKey extends keyof TDef['endpoints'][TDomain] // Using direct keyof for simplicity
+    TRouteKey extends keyof TDef['endpoints'][TDomain], // Using direct keyof for simplicity
+    Ctx extends Record<string, any> = Record<string, any>
 >(
     domain: TDomain,
     routeKey: TRouteKey,
     handler: (
-        // Use the TDef generic for TypedRequest and TypedResponse
-        req: TypedRequest<TDef, TDomain, TRouteKey>,
+        // Use the TDef generic for TypedRequest and TypedResponse with Ctx
+        req: TypedRequest<TDef, TDomain, TRouteKey, any, any, any, any, Ctx>,
         res: TypedResponse<TDef, TDomain, TRouteKey>
     ) => Promise<void> | void
 ) {

package/tests/middleware.test.ts

@@ -0,0 +1,84 @@
+import { describe, test, expect } from '@jest/globals';
+import { ApiClient } from '../src';
+import { MiddlewareTestApiDefinition } from './setup';
+
+// Test servers with middleware (will be defined in setup.ts)
+export const MIDDLEWARE_EXPRESS_PORT = 3007;
+export const MIDDLEWARE_HONO_PORT = 3008;
+
+describe.each([
+    ['Express', MIDDLEWARE_EXPRESS_PORT],
+    ['Hono', MIDDLEWARE_HONO_PORT]
+])('Middleware Tests - %s', (serverName, port) => {
+    const baseUrl = `http://localhost:${port}`;
+    const client = new ApiClient(baseUrl, MiddlewareTestApiDefinition);
+
+    describe('Basic Middleware Functionality', () => {
+        test('should execute middleware and allow request to proceed', async () => {
+            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');
+        });
+    });
+
+    describe('Context Modification Middleware', () => {
+        test('should have access to context data set by middleware', async () => {
+            const result = await client.callApi('public', 'context', {}, {
+                200: ({ data }) => {
+                    expect(data.message).toBe('context test');
+                    expect(data.contextData).toBe('middleware-added-data');
+                    return data;
+                },
+                422: ({ error }) => {
+                    throw new Error(`Validation error: ${JSON.stringify(error)}`);
+                }
+            });
+
+            expect(result.contextData).toBe('middleware-added-data');
+        });
+    });
+
+    describe('Authentication Middleware', () => {
+        test('should allow access with valid auth header', async () => {
+            // This test assumes the middleware checks for an 'authorization' header
+            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}`);
+                },
+                422: ({ error }) => {
+                    throw new Error(`Validation error: ${JSON.stringify(error)}`);
+                }
+            });
+
+            expect(result.user).toBe('testuser');
+        });
+
+        test('should deny access without auth header', 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');
+                    },
+                    422: ({ error }) => {
+                        throw new Error(`Validation error: ${JSON.stringify(error)}`);
+                    }
+                })
+            ).rejects.toThrow('Authentication failed as expected');
+        });
+    });
+});

package/tests/setup.ts

@@ -5,8 +5,9 @@ import http from 'http';
 import { Hono } from 'hono';
 import { PublicApiDefinition as SimplePublicApiDefinition, PrivateApiDefinition as SimplePrivateApiDefinition } from '../examples/simple/definitions';
 import { PublicApiDefinition as AdvancedPublicApiDefinition, PrivateApiDefinition as AdvancedPrivateApiDefinition } from '../examples/advanced/definitions';
-import { RegisterHandlers, RegisterHonoHandlers, CreateApiDefinition, CreateResponses } from '../src';
+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 = {
@@ -202,6 +203,36 @@ const fileUploadHandlers = {
     }
 };
 
+export const MiddlewareTestApiDefinition = CreateApiDefinition({
+    prefix: '/api/v1',
+    endpoints: {
+        public: {
+            ping: {
+                method: 'GET' as const,
+                path: '/ping',
+                responses: CreateResponses({
+                    200: z.object({ message: z.string() })
+                })
+            },
+            protected: {
+                method: 'GET' as const,
+                path: '/protected',
+                responses: CreateResponses({
+                    200: z.object({ message: z.string(), user: z.string() }),
+                    401: z.object({ error: z.string() })
+                })
+            },
+            context: {
+                method: 'GET' as const,
+                path: '/context',
+                responses: CreateResponses({
+                    200: z.object({ message: z.string(), contextData: z.string() })
+                })
+            }
+        }
+    }
+});
+
 // Global test server instances
 export let simpleServer: Server;
 export let advancedServer: Server;
@@ -209,6 +240,8 @@ export let fileUploadServer: Server;
 export let honoServer: Server;
 export let advancedHonoServer: Server;
 export let fileUploadHonoServer: Server;
+export let middlewareExpressServer: Server;
+export let middlewareHonoServer: Server;
 
 export const SIMPLE_PORT = 3001;
 export const ADVANCED_PORT = 3002;
@@ -216,6 +249,8 @@ export const FILE_UPLOAD_PORT = 3003;
 export const HONO_PORT = 3004;
 export const ADVANCED_HONO_PORT = 3005;
 export const FILE_UPLOAD_HONO_PORT = 3006;
+export const MIDDLEWARE_EXPRESS_PORT = 3007;
+export const MIDDLEWARE_HONO_PORT = 3008;
 
 // Helper function to create HTTP server wrapper for Hono apps
 function createHonoHttpServer(server: any, port: number, errorPrefix: string): Server {
@@ -267,6 +302,8 @@ beforeAll(async () => {
     await startHonoServer();
     await startAdvancedHonoServer();
     await startFileUploadHonoServer();
+    await startMiddlewareExpressServer();
+    await startMiddlewareHonoServer();
 });
 
 afterAll(async () => {
@@ -289,6 +326,12 @@ afterAll(async () => {
     if (fileUploadHonoServer) {
         fileUploadHonoServer.close();
     }
+    if (middlewareExpressServer) {
+        middlewareExpressServer.close();
+    }
+    if (middlewareHonoServer) {
+        middlewareHonoServer.close();
+    }
 });
 
 async function startSimpleServer(): Promise<void> {
@@ -399,3 +442,132 @@ async function startHonoServer(): Promise<void> {
         });
     });
 }
+
+type Ctx = { user: string }
+
+// Middleware test servers
+async function startMiddlewareExpressServer(): Promise<void> {
+    return new Promise((resolve) => {
+        const app = express();
+        app.use(express.json());
+
+        // Define middleware functions
+        const loggingMiddleware = (req: express.Request, res: express.Response, next: express.NextFunction, endpointInfo: any) => {
+            console.log(`[Test] ${req.method} ${req.path} - Domain: ${endpointInfo.domain}, Route: ${endpointInfo.routeKey}`);
+            next();
+        };
+
+        const contextMiddleware = (req: express.Request, res: express.Response, next: express.NextFunction) => {
+            (req as any).ctx = { middlewareData: "middleware-added-data" };
+            next();
+        };
+
+        const authMiddleware: EndpointMiddlewareCtx<Ctx> = (req, res, next) => {
+            const authHeader = req.headers.authorization;
+            if (authHeader === 'Bearer valid-token') {
+                req.ctx = { user: 'testuser' };
+            }
+            next();
+        };
+
+        // Register handlers with middleware
+        RegisterHandlers(app, MiddlewareTestApiDefinition, {
+            public: {
+                ping: async (req: any, res: any) => {
+                    res.respond(200, { message: "pong" });
+                },
+                protected: async (req, res) => {
+                    // Check if user is authenticated via context
+                    if (req.ctx && req.ctx.user) {
+                        res.respond(200, {
+                            message: "protected content",
+                            user: req.ctx.user
+                        });
+                    } else {
+                        res.respond(401, { error: "No authorization header" });
+                    }
+                },
+                context: async (req: any, res: any) => {
+                    res.respond(200, {
+                        message: "context test",
+                        contextData: req.ctx?.middlewareData || "default"
+                    });
+                }
+            }
+        }, [
+            loggingMiddleware,
+            contextMiddleware,
+            authMiddleware
+        ]);
+
+        middlewareExpressServer = app.listen(MIDDLEWARE_EXPRESS_PORT, () => {
+            resolve();
+        });
+    });
+}
+
+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
+        ]);
+
+        // Create HTTP server from Hono app
+        const server = app.fetch;
+
+        // Create a simple HTTP server wrapper for Hono
+        middlewareHonoServer = createHonoHttpServer(server, MIDDLEWARE_HONO_PORT, 'Middleware Hono server');
+
+        middlewareHonoServer.listen(MIDDLEWARE_HONO_PORT, () => {
+            resolve();
+        });
+    });
+}