ts-typed-api 0.2.20 → 0.2.21

package/dist/handler.js

@@ -343,28 +343,37 @@ middlewares) {
                     ? routeDefinition.body.parse(expressReq.body)
                     : expressReq.body;
                 // Construct TypedRequest using TDef, currentDomain, currentRouteKey
-                const finalTypedReq = {
-                    ...expressReq,
-                    params: parsedParams,
-                    query: parsedQuery,
-                    body: parsedBody,
-                    ctx: expressReq.ctx,
-                    headers: expressReq.headers,
-                    cookies: expressReq.cookies,
-                    ip: expressReq.ip,
-                    ips: expressReq.ips,
-                    hostname: expressReq.hostname,
-                    protocol: expressReq.protocol,
-                    secure: expressReq.secure,
-                    xhr: expressReq.xhr,
-                    fresh: expressReq.fresh,
-                    stale: expressReq.stale,
-                    subdomains: expressReq.subdomains,
-                    path: expressReq.path,
-                    originalUrl: expressReq.originalUrl,
-                    baseUrl: expressReq.baseUrl,
-                    url: expressReq.url,
-                };
+                // Create a new object that inherits from expressReq to preserve prototype methods like .on()
+                const finalTypedReq = Object.create(expressReq, {
+                    // Core parsed/validated properties
+                    params: { value: parsedParams, writable: true, enumerable: true, configurable: true },
+                    query: { value: parsedQuery, writable: true, enumerable: true, configurable: true },
+                    body: { value: parsedBody, writable: true, enumerable: true, configurable: true },
+                    ctx: { value: expressReq.ctx, writable: true, enumerable: true, configurable: true },
+                    // Unified API for client disconnection
+                    onClose: {
+                        value: (callback) => expressReq.on('close', callback),
+                        writable: false,
+                        enumerable: true,
+                        configurable: false
+                    },
+                    // Restore original Express request properties for full compatibility
+                    headers: { value: expressReq.headers, writable: false, enumerable: true, configurable: false },
+                    cookies: { value: expressReq.cookies, writable: false, enumerable: true, configurable: false },
+                    ip: { value: expressReq.ip, writable: false, enumerable: true, configurable: false },
+                    ips: { value: expressReq.ips, writable: false, enumerable: true, configurable: false },
+                    hostname: { value: expressReq.hostname, writable: false, enumerable: true, configurable: false },
+                    protocol: { value: expressReq.protocol, writable: false, enumerable: true, configurable: false },
+                    secure: { value: expressReq.secure, writable: false, enumerable: true, configurable: false },
+                    xhr: { value: expressReq.xhr, writable: false, enumerable: true, configurable: false },
+                    fresh: { value: expressReq.fresh, writable: false, enumerable: true, configurable: false },
+                    stale: { value: expressReq.stale, writable: false, enumerable: true, configurable: false },
+                    subdomains: { value: expressReq.subdomains, writable: false, enumerable: true, configurable: false },
+                    path: { value: expressReq.path, writable: false, enumerable: true, configurable: false },
+                    originalUrl: { value: expressReq.originalUrl, writable: false, enumerable: true, configurable: false },
+                    baseUrl: { value: expressReq.baseUrl, writable: false, enumerable: true, configurable: false },
+                    url: { value: expressReq.url, writable: false, enumerable: true, configurable: false },
+                });
                 // Augment expressRes with the .respond and .setHeader methods, using TDef
                 const typedExpressRes = expressRes;
                 typedExpressRes.respond = (status, dataForResponse) => {

package/dist/hono-cloudflare-workers.js

@@ -389,7 +389,9 @@ function registerHonoRouteHandlers(app, apiDefinition, routeHandlers, middleware
                     ip: c.req.header('CF-Connecting-IP') || '127.0.0.1',
                     method: c.req.method,
                     path: c.req.path,
-                    originalUrl: c.req.url
+                    originalUrl: c.req.url,
+                    // Hono doesn't support long-lived connections, so onClose is undefined
+                    onClose: undefined
                 };
                 const fakeRes = {
                     respond: c.respond,

package/dist/router.d.ts

@@ -9,6 +9,7 @@ P extends ApiParams<TDef, TDomain, TRouteKey> = ApiParams<TDef, TDomain, TRouteK
         [fieldname: string]: File[];
     };
     ctx?: Ctx;
+    onClose?: (callback: () => void) => void;
 };
 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;

package/examples/simple/definitions.ts

@@ -77,6 +77,20 @@ export const PublicApiDefinition = CreateApiDefinition({
                     200: z.string() // Raw SSE data
                 })
             },
+            disconnectTest: {
+                method: 'GET',
+                path: '/disconnect-test',
+                description: 'Endpoint for testing client disconnection handling',
+                query: z.object({
+                    delay: z.number().int().min(100).max(5000).optional().default(1000)
+                }),
+                responses: CreateResponses({
+                    200: z.object({
+                        message: z.string(),
+                        disconnected: z.boolean()
+                    }),
+                })
+            },
         }
     }
 })

package/package.json

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

@@ -401,28 +401,39 @@ export function registerRouteHandlers<TDef extends ApiDefinitionSchema>(
                     : expressReq.body;
 
                 // Construct TypedRequest using TDef, currentDomain, currentRouteKey
-                const finalTypedReq = {
-                    ...expressReq,
-                    params: parsedParams,
-                    query: parsedQuery,
-                    body: parsedBody,
-                    ctx: (expressReq as any).ctx,
-                    headers: expressReq.headers,
-                    cookies: expressReq.cookies,
-                    ip: expressReq.ip,
-                    ips: expressReq.ips,
-                    hostname: expressReq.hostname,
-                    protocol: expressReq.protocol,
-                    secure: expressReq.secure,
-                    xhr: expressReq.xhr,
-                    fresh: expressReq.fresh,
-                    stale: expressReq.stale,
-                    subdomains: expressReq.subdomains,
-                    path: expressReq.path,
-                    originalUrl: expressReq.originalUrl,
-                    baseUrl: expressReq.baseUrl,
-                    url: expressReq.url,
-                } as TypedRequest<TDef, typeof currentDomain, typeof currentRouteKey>;
+                // Create a new object that inherits from expressReq to preserve prototype methods like .on()
+                const finalTypedReq = Object.create(expressReq, {
+                    // Core parsed/validated properties
+                    params: { value: parsedParams, writable: true, enumerable: true, configurable: true },
+                    query: { value: parsedQuery, writable: true, enumerable: true, configurable: true },
+                    body: { value: parsedBody, writable: true, enumerable: true, configurable: true },
+                    ctx: { value: (expressReq as any).ctx, writable: true, enumerable: true, configurable: true },
+
+                    // Unified API for client disconnection
+                    onClose: {
+                        value: (callback: () => void) => expressReq.on('close', callback),
+                        writable: false,
+                        enumerable: true,
+                        configurable: false
+                    },
+
+                    // Restore original Express request properties for full compatibility
+                    headers: { value: expressReq.headers, writable: false, enumerable: true, configurable: false },
+                    cookies: { value: expressReq.cookies, writable: false, enumerable: true, configurable: false },
+                    ip: { value: expressReq.ip, writable: false, enumerable: true, configurable: false },
+                    ips: { value: expressReq.ips, writable: false, enumerable: true, configurable: false },
+                    hostname: { value: expressReq.hostname, writable: false, enumerable: true, configurable: false },
+                    protocol: { value: expressReq.protocol, writable: false, enumerable: true, configurable: false },
+                    secure: { value: expressReq.secure, writable: false, enumerable: true, configurable: false },
+                    xhr: { value: expressReq.xhr, writable: false, enumerable: true, configurable: false },
+                    fresh: { value: expressReq.fresh, writable: false, enumerable: true, configurable: false },
+                    stale: { value: expressReq.stale, writable: false, enumerable: true, configurable: false },
+                    subdomains: { value: expressReq.subdomains, writable: false, enumerable: true, configurable: false },
+                    path: { value: expressReq.path, writable: false, enumerable: true, configurable: false },
+                    originalUrl: { value: expressReq.originalUrl, writable: false, enumerable: true, configurable: false },
+                    baseUrl: { value: expressReq.baseUrl, writable: false, enumerable: true, configurable: false },
+                    url: { value: expressReq.url, writable: false, enumerable: true, configurable: false },
+                }) as TypedRequest<TDef, typeof currentDomain, typeof currentRouteKey>;
 
                 // Augment expressRes with the .respond and .setHeader methods, using TDef
                 const typedExpressRes = expressRes as TypedResponse<TDef, typeof currentDomain, typeof currentRouteKey>;

package/src/hono-cloudflare-workers.ts

@@ -471,7 +471,9 @@ export function registerHonoRouteHandlers<
                     ip: c.req.header('CF-Connecting-IP') || '127.0.0.1',
                     method: c.req.method,
                     path: c.req.path,
-                    originalUrl: c.req.url
+                    originalUrl: c.req.url,
+                    // Hono doesn't support long-lived connections, so onClose is undefined
+                    onClose: undefined
                 } as TypedRequest<TDef, typeof currentDomain, typeof currentRouteKey>;
 
                 const fakeRes = {

package/src/router.ts

@@ -27,6 +27,8 @@ export type TypedRequest<
     files?: File[] | { [fieldname: string]: File[] };
     // Add typed context object for carrying data between middlewares and handlers
     ctx?: Ctx;
+    // Unified client disconnection handler (Express only, undefined for Hono)
+    onClose?: (callback: () => void) => void;
 }
 
 // --- Enhanced TypedResponse with res.respond, now generic over TDef ---

package/tests/setup.ts

@@ -50,6 +50,25 @@ const simplePublicHandlers = {
 
             // Close the stream
             res.endStream();
+        },
+        disconnectTest: async (req: any, res: any) => {
+            const delay = req.query?.delay || 1000;
+            let disconnected = false;
+
+            // Set up disconnection handler using unified API
+            req.onClose?.(() => {
+                console.log('Client disconnected during disconnect-test');
+                disconnected = true;
+            });
+
+            // Simulate long-running operation
+            await new Promise(resolve => setTimeout(resolve, delay));
+
+            // Check if client disconnected during the delay
+            res.respond(200, {
+                message: disconnected ? 'Client disconnected' : 'Operation completed',
+                disconnected
+            });
         }
     },
     status: {

package/tests/simple-api.test.ts

@@ -251,6 +251,62 @@ describe.each([
             return data ? JSON.parse(data) : null;
         }
 
+        test('should handle client disconnection with req.onClose', async () => {
+            // Test that the endpoint works normally when client doesn't disconnect
+            const result = await client.callApi('common', 'disconnectTest', {
+                query: { delay: 100 }
+            }, {
+                200: ({ data }) => {
+                    expect(data.message).toBe('Operation completed');
+                    expect(data.disconnected).toBe(false);
+                    return data;
+                },
+                422: ({ error }) => {
+                    throw new Error(`Validation error: ${JSON.stringify(error)}`);
+                }
+            });
+
+            expect(result.disconnected).toBe(false);
+        });
+
+        test('should detect client disconnection during request processing', async () => {
+            if (serverName === 'Hono') {
+                // Hono doesn't support disconnection detection, so onClose is undefined
+                // The endpoint completes successfully but doesn't detect disconnections
+                const response = await fetch(`${baseUrl}/api/v1/public/disconnect-test?delay=100`);
+                expect(response.status).toBe(200);
+                const data = await response.json();
+                expect(data.data.disconnected).toBe(false); // No disconnection detected
+                return;
+            }
+
+            // Use fetch directly with AbortController to simulate client disconnection
+            const controller = new AbortController();
+            const signal = controller.signal;
+
+            // Start the request
+            const fetchPromise = fetch(`${baseUrl}/api/v1/public/disconnect-test?delay=500`, {
+                signal,
+                headers: { 'Accept': 'application/json' }
+            });
+
+            // Abort the request after a short delay (before the server finishes)
+            setTimeout(() => {
+                controller.abort();
+            }, 200);
+
+            // The request should be aborted (node-fetch uses different error messages)
+            await expect(fetchPromise).rejects.toThrow(/aborted/i);
+
+            // Give the server a moment to process the disconnection
+            await new Promise(resolve => setTimeout(resolve, 100));
+
+            // Note: In a real test environment, we would need a way to verify
+            // that the close handler was called on the server side.
+            // For this test, we're mainly verifying that the endpoint exists
+            // and that client disconnection doesn't crash the server.
+        });
+
         test('generateUrl should return correct URL for ping', () => {
             const url = client.generateUrl('common', 'ping');
             expect(url).toBe(`${baseUrl}/api/v1/public/ping`);