ts-typed-api 0.2.9 → 0.2.11

package/dist/hono-only.d.ts

@@ -1,9 +1,6 @@
-import type { ApiDefinitionSchema } from './definition';
-import type { TypedRequest, TypedResponse } from './router';
 export { CreateApiDefinition, CreateResponses } from './definition';
 export { z as ZodSchema } from 'zod';
 export { EndpointMiddleware, EndpointMiddlewareCtx } from './object-handlers';
-export declare function createTypedHandler<TDef extends ApiDefinitionSchema, TDomain extends keyof TDef['endpoints'], TRouteKey extends keyof TDef['endpoints'][TDomain], Ctx extends Record<string, any> = Record<string, any>>(handler: (req: TypedRequest<TDef, TDomain, TRouteKey, any, any, any, any, Ctx>, res: TypedResponse<TDef, TDomain, TRouteKey>) => Promise<void> | void): (req: TypedRequest<TDef, TDomain, TRouteKey, any, any, any, any, Ctx>, res: TypedResponse<TDef, TDomain, TRouteKey>) => Promise<void> | void;
 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,17 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CreateTypedHonoHandlerWithContext = exports.RegisterHonoHandlers = exports.ZodSchema = exports.CreateResponses = exports.CreateApiDefinition = void 0;
-exports.createTypedHandler = createTypedHandler;
+// Hono-only exports - for Cloudflare Workers and other Hono environments
+// Excludes Express dependencies like multer, busboy, etc.
 var definition_1 = require("./definition");
 Object.defineProperty(exports, "CreateApiDefinition", { enumerable: true, get: function () { return definition_1.CreateApiDefinition; } });
 Object.defineProperty(exports, "CreateResponses", { enumerable: true, get: function () { return definition_1.CreateResponses; } });
 var zod_1 = require("zod");
 Object.defineProperty(exports, "ZodSchema", { enumerable: true, get: function () { return zod_1.z; } });
-// Helper function to create typed handlers with proper type inference
-// Defined locally to avoid Express dependencies in Hono-only bundle
-function createTypedHandler(handler) {
-    return handler;
-}
 // 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; } });

package/dist/index.d.ts

@@ -2,7 +2,7 @@ export { ApiClient, FetchHttpClientAdapter } from './client';
 export { generateOpenApiSpec } from './openapi';
 export { generateOpenApiSpec as generateOpenApiSpec2 } from './openapi-self';
 export { CreateApiDefinition, CreateResponses, ApiDefinitionSchema } from './definition';
-export { RegisterHandlers, EndpointMiddleware, UniversalEndpointMiddleware, SimpleMiddleware, EndpointInfo, createTypedHandler } from './object-handlers';
+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, CreateTypedHonoHandlerWithContext } from './hono-cloudflare-workers';

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CreateTypedHonoHandlerWithContext = exports.honoFileSchema = exports.registerHonoRouteHandlers = exports.RegisterHonoHandlers = exports.ZodSchema = exports.createTypedHandler = 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; } });
@@ -13,7 +13,6 @@ Object.defineProperty(exports, "CreateApiDefinition", { enumerable: true, get: f
 Object.defineProperty(exports, "CreateResponses", { enumerable: true, get: function () { return definition_1.CreateResponses; } });
 var object_handlers_1 = require("./object-handlers");
 Object.defineProperty(exports, "RegisterHandlers", { enumerable: true, get: function () { return object_handlers_1.RegisterHandlers; } });
-Object.defineProperty(exports, "createTypedHandler", { enumerable: true, get: function () { return object_handlers_1.createTypedHandler; } });
 var zod_1 = require("zod");
 Object.defineProperty(exports, "ZodSchema", { enumerable: true, get: function () { return zod_1.z; } });
 // Hono adapter for Cloudflare Workers

package/dist/object-handlers.d.ts

@@ -1,5 +1,5 @@
 import express from "express";
-import { ApiDefinitionSchema } from "./definition";
+import { ApiDefinitionSchema, ApiParams, ApiBody, ApiQuery } from "./definition";
 import { TypedRequest, TypedResponse } from "./router";
 export type EndpointInfo<TDef extends ApiDefinitionSchema = ApiDefinitionSchema> = {
     [TDomain in keyof TDef['endpoints']]: {
@@ -17,13 +17,12 @@ export type EndpointMiddlewareCtx<Ctx extends Record<string, any> = Record<strin
     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], 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;
+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>> = {
     [TDomain in keyof TDef['endpoints']]: {
         [TRouteKey in keyof TDef['endpoints'][TDomain]]: HandlerFunction<TDef, TDomain, TRouteKey, Ctx>;
     };
 };
 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 createTypedHandler<TDef extends ApiDefinitionSchema, TDomain extends keyof TDef['endpoints'], TRouteKey extends keyof TDef['endpoints'][TDomain], Ctx extends Record<string, any> = Record<string, any>>(handler: (req: TypedRequest<TDef, TDomain, TRouteKey, any, any, any, any, Ctx>, res: TypedResponse<TDef, TDomain, TRouteKey>) => Promise<void> | void): (req: TypedRequest<TDef, TDomain, TRouteKey, any, any, any, any, Ctx>, res: TypedResponse<TDef, TDomain, TRouteKey>) => Promise<void> | void;
 export declare function makeObjectHandlerRegistrar<TDef extends ApiDefinitionSchema>(apiDefinition: TDef): (app: express.Express, objectHandlers: ObjectHandlers<TDef>, middlewares?: EndpointMiddleware<TDef>[]) => void;
 export {};

package/dist/object-handlers.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RegisterHandlers = RegisterHandlers;
-exports.createTypedHandler = createTypedHandler;
 exports.makeObjectHandlerRegistrar = makeObjectHandlerRegistrar;
 const handler_1 = require("./handler");
 // Transform object-based handlers to array format
@@ -46,10 +45,6 @@ function RegisterHandlers(app, apiDefinition, objectHandlers, middlewares) {
     }) || [];
     (0, handler_1.registerRouteHandlers)(app, apiDefinition, handlerArray, endpointMiddlewares);
 }
-// Helper function to create typed handlers with proper type inference
-function createTypedHandler(handler) {
-    return handler;
-}
 // Factory function to create a typed handler registrar for a specific API definition
 function makeObjectHandlerRegistrar(apiDefinition) {
     return function (app, objectHandlers, middlewares) {

package/dist/router.d.ts

@@ -17,10 +17,10 @@ export interface TypedResponse<TDef extends ApiDefinitionSchema, TDomain extends
     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
-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): {
+Ctx extends Record<string, any> = Record<string, any>>(domain: TDomain, routeKey: TRouteKey, handler: (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): {
     domain: TDomain;
     routeKey: TRouteKey;
-    handler: (req: TypedRequest<TDef, TDomain, TRouteKey, any, any, any, any, Ctx>, res: TypedResponse<TDef, TDomain, TRouteKey>) => Promise<void> | void;
+    handler: (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 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/examples/hono-cloudflare-worker-example.ts

@@ -1,5 +1,5 @@
 import { Hono } from 'hono';
-import { RegisterHonoHandlers, createTypedHandler } from '../src';
+import { RegisterHonoHandlers } from '../src';
 import { PublicApiDefinition, PrivateApiDefinition } from './simple/definitions';
 
 // Create Hono app for Cloudflare Workers
@@ -45,10 +45,10 @@ RegisterHonoHandlers(app, PublicApiDefinition, {
 // Register private handlers with auth
 RegisterHonoHandlers(app, PrivateApiDefinition, {
     user: {
-        get: createTypedHandler(async (req, res) => {
+        get: async (req, res) => {
             console.log('Fetching user', req.params.id);
             res.respond(200, "ok");
-        })
+        }
     }
 }, [loggingMiddleware, authMiddleware]);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-typed-api",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "description": "A lightweight, type-safe RPC library for TypeScript with Zod validation",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/hono-only.ts

@@ -1,27 +1,9 @@
 // Hono-only exports - for Cloudflare Workers and other Hono environments
 // Excludes Express dependencies like multer, busboy, etc.
-import type { ApiDefinitionSchema } from './definition';
-import type { TypedRequest, TypedResponse } from './router';
-
 export { CreateApiDefinition, CreateResponses } from './definition';
 export { z as ZodSchema } from 'zod';
 export { EndpointMiddleware, EndpointMiddlewareCtx } from './object-handlers'
 
-// Helper function to create typed handlers with proper type inference
-// Defined locally to avoid Express dependencies in Hono-only bundle
-export function createTypedHandler<
-    TDef extends ApiDefinitionSchema,
-    TDomain extends keyof TDef['endpoints'],
-    TRouteKey extends keyof TDef['endpoints'][TDomain],
-    Ctx extends Record<string, any> = Record<string, any>
->(
-    handler: (
-        req: TypedRequest<TDef, TDomain, TRouteKey, any, any, any, any, Ctx>,
-        res: TypedResponse<TDef, TDomain, TRouteKey>
-    ) => Promise<void> | void
-) {
-    return handler;
-}
 
 // Hono adapter for Cloudflare Workers
 export { RegisterHonoHandlers, CreateTypedHonoHandlerWithContext } from './hono-cloudflare-workers';

package/src/index.ts

@@ -2,7 +2,7 @@ export { ApiClient, FetchHttpClientAdapter } from './client';
 export { generateOpenApiSpec } from './openapi'
 export { generateOpenApiSpec as generateOpenApiSpec2 } from './openapi-self'
 export { CreateApiDefinition, CreateResponses, ApiDefinitionSchema } from './definition';
-export { RegisterHandlers, EndpointMiddleware, UniversalEndpointMiddleware, SimpleMiddleware, EndpointInfo, createTypedHandler } from './object-handlers';
+export { RegisterHandlers, EndpointMiddleware, UniversalEndpointMiddleware, SimpleMiddleware, EndpointInfo } from './object-handlers';
 export { File as UploadedFile } from './router';
 export { z as ZodSchema } from 'zod';
 

package/src/object-handlers.ts

@@ -1,5 +1,5 @@
 import express from "express";
-import { ApiDefinitionSchema } from "./definition";
+import { ApiDefinitionSchema, ApiParams, ApiBody, ApiQuery } from "./definition";
 import { registerRouteHandlers, SpecificRouteHandler } from "./handler";
 import { TypedRequest, TypedResponse } from "./router";
 
@@ -59,7 +59,7 @@ type HandlerFunction<
     TRouteKey extends keyof TDef['endpoints'][TDomain],
     Ctx extends Record<string, any> = Record<string, any>
 > = (
-    req: TypedRequest<TDef, TDomain, TRouteKey, any, any, any, any, Ctx>,
+    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;
 
@@ -136,21 +136,6 @@ export function RegisterHandlers<
     registerRouteHandlers(app, apiDefinition, handlerArray, endpointMiddlewares);
 }
 
-// Helper function to create typed handlers with proper type inference
-export function createTypedHandler<
-    TDef extends ApiDefinitionSchema,
-    TDomain extends keyof TDef['endpoints'],
-    TRouteKey extends keyof TDef['endpoints'][TDomain],
-    Ctx extends Record<string, any> = Record<string, any>
->(
-    handler: (
-        req: TypedRequest<TDef, TDomain, TRouteKey, any, any, any, any, Ctx>,
-        res: TypedResponse<TDef, TDomain, TRouteKey>
-    ) => Promise<void> | void
-) {
-    return handler;
-}
-
 // Factory function to create a typed handler registrar for a specific API definition
 export function makeObjectHandlerRegistrar<TDef extends ApiDefinitionSchema>(
     apiDefinition: TDef

package/src/router.ts

@@ -74,7 +74,7 @@ export function createRouteHandler<
     routeKey: TRouteKey,
     handler: (
         // Use the TDef generic for TypedRequest and TypedResponse with Ctx
-        req: TypedRequest<TDef, TDomain, TRouteKey, any, any, any, any, Ctx>,
+        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
 ) {