ts-typed-api 0.2.14 → 0.2.16

package/dist/client.d.ts

@@ -128,6 +128,18 @@ export declare class ApiClient<TActualDef extends BaseApiDefinitionSchema> {
      * @returns The base URL with prefix applied.
      */
     private getBaseUrlWithPrefix;
+    /**
+     * Generates the full URL for a specific route, incorporating path parameters and query parameters.
+     * @template TDomain The domain (controller) of the API.
+     * @template TRouteKey The key of the route within the domain.
+     * @param domain The API domain (e.g., 'user').
+     * @param routeKey The API route key (e.g., 'getUsers').
+     * @param params Optional path parameters to replace in the route path.
+     * @param query Optional query parameters to append to the URL.
+     * @returns The full URL as a string.
+     * @throws Error if the route configuration is invalid.
+     */
+    generateUrl<TDomain extends keyof TActualDef['endpoints'], TRouteKey extends keyof TActualDef['endpoints'][TDomain]>(domain: TDomain, routeKey: TRouteKey, params?: ApiClientParams<TActualDef, TDomain, TRouteKey>, query?: ApiClientQuery<TActualDef, TDomain, TRouteKey>): string;
     /**
      * Makes an API call to a specified domain and route.
      * @template TDomain The domain (controller) of the API.

package/dist/client.js

@@ -88,6 +88,42 @@ class ApiClient {
         }
         return this.baseUrl;
     }
+    /**
+     * Generates the full URL for a specific route, incorporating path parameters and query parameters.
+     * @template TDomain The domain (controller) of the API.
+     * @template TRouteKey The key of the route within the domain.
+     * @param domain The API domain (e.g., 'user').
+     * @param routeKey The API route key (e.g., 'getUsers').
+     * @param params Optional path parameters to replace in the route path.
+     * @param query Optional query parameters to append to the URL.
+     * @returns The full URL as a string.
+     * @throws Error if the route configuration is invalid.
+     */
+    generateUrl(domain, routeKey, params, query) {
+        const routeInfo = this.apiDefinitionObject.endpoints[domain][routeKey];
+        if (!routeInfo || typeof routeInfo.path !== 'string') {
+            throw new Error(`API route configuration ${String(domain)}.${String(routeKey)} not found or invalid.`);
+        }
+        let urlPath = routeInfo.path;
+        if (params) {
+            const paramsRecord = params;
+            for (const key in paramsRecord) {
+                if (Object.prototype.hasOwnProperty.call(paramsRecord, key) && paramsRecord[key] !== undefined) {
+                    urlPath = urlPath.replace(`:${key}`, String(paramsRecord[key]));
+                }
+            }
+        }
+        const url = new URL(this.getBaseUrlWithPrefix() + urlPath);
+        if (query) {
+            const queryRecord = query;
+            for (const key in queryRecord) {
+                if (Object.prototype.hasOwnProperty.call(queryRecord, key) && queryRecord[key] !== undefined) {
+                    url.searchParams.append(key, String(queryRecord[key]));
+                }
+            }
+        }
+        return url.toString();
+    }
     /**
      * Makes an API call to a specified domain and route.
      * @template TDomain The domain (controller) of the API.

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);
             }

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);

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.14",
+  "version": "0.2.16",
   "description": "A lightweight, type-safe RPC library for TypeScript with Zod validation",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/client.ts

@@ -216,6 +216,56 @@ export class ApiClient<TActualDef extends BaseApiDefinitionSchema> { // Made gen
         return this.baseUrl;
     }
 
+    /**
+     * Generates the full URL for a specific route, incorporating path parameters and query parameters.
+     * @template TDomain The domain (controller) of the API.
+     * @template TRouteKey The key of the route within the domain.
+     * @param domain The API domain (e.g., 'user').
+     * @param routeKey The API route key (e.g., 'getUsers').
+     * @param params Optional path parameters to replace in the route path.
+     * @param query Optional query parameters to append to the URL.
+     * @returns The full URL as a string.
+     * @throws Error if the route configuration is invalid.
+     */
+    public generateUrl<
+        TDomain extends keyof TActualDef['endpoints'],
+        TRouteKey extends keyof TActualDef['endpoints'][TDomain]
+    >(
+        domain: TDomain,
+        routeKey: TRouteKey,
+        params?: ApiClientParams<TActualDef, TDomain, TRouteKey>,
+        query?: ApiClientQuery<TActualDef, TDomain, TRouteKey>
+    ): string {
+        const routeInfo = this.apiDefinitionObject.endpoints[domain as string][routeKey as string] as RouteSchema;
+
+        if (!routeInfo || typeof routeInfo.path !== 'string') {
+            throw new Error(`API route configuration ${String(domain)}.${String(routeKey)} not found or invalid.`);
+        }
+
+        let urlPath = routeInfo.path;
+        if (params) {
+            const paramsRecord = params as Record<string, string | number | boolean>;
+            for (const key in paramsRecord) {
+                if (Object.prototype.hasOwnProperty.call(paramsRecord, key) && paramsRecord[key] !== undefined) {
+                    urlPath = urlPath.replace(`:${key}`, String(paramsRecord[key]));
+                }
+            }
+        }
+
+        const url = new URL(this.getBaseUrlWithPrefix() + urlPath);
+
+        if (query) {
+            const queryRecord = query as Record<string, any>;
+            for (const key in queryRecord) {
+                if (Object.prototype.hasOwnProperty.call(queryRecord, key) && queryRecord[key] !== undefined) {
+                    url.searchParams.append(key, String(queryRecord[key]));
+                }
+            }
+        }
+
+        return url.toString();
+    }
+
     /**
      * Makes an API call to a specified domain and route.
      * @template TDomain The domain (controller) of the API.

package/src/handler.ts

@@ -355,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) => {
@@ -408,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>

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 (

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

@@ -14,6 +14,11 @@ 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: {

package/tests/simple-api.test.ts

@@ -74,6 +74,59 @@ 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');
+        });
+
+        test('generateUrl should return correct URL for ping', () => {
+            const url = client.generateUrl('common', 'ping');
+            expect(url).toBe(`${baseUrl}/api/v1/public/ping`);
+        });
+
+        test('generateUrl should return correct URL for probe1 without query', () => {
+            const url = client.generateUrl('status', 'probe1');
+            expect(url).toBe(`${baseUrl}/api/v1/public/status/probe1`);
+        });
+
+        test('generateUrl should return correct URL for probe1 with query', () => {
+            const url = client.generateUrl('status', 'probe1', undefined, { match: true });
+            expect(url).toBe(`${baseUrl}/api/v1/public/status/probe1?match=true`);
+        });
+
+        test('generateUrl should return correct URL for probe2', () => {
+            const url = client.generateUrl('status', 'probe2');
+            expect(url).toBe(`${baseUrl}/api/v1/public/status/probe2`);
+        });
     });
 
     describe('Private API', () => {
@@ -94,6 +147,11 @@ describe.each([
 
             expect(result).toBe('ok');
         });
+
+        test('generateUrl should return correct URL for user get with params', () => {
+            const url = client.generateUrl('user', 'get', { id: 'test-id' });
+            expect(url).toBe(`${baseUrl}/api/v1/private/user/test-id`);
+        });
     });
 
     describe('Strict Validation Tests', () => {