kayto_ts 0.1.10 → 0.1.12

package/README.md

@@ -2,7 +2,9 @@
 
 [📦 npm: kayto_ts](https://www.npmjs.com/package/kayto_ts)
 
-🚀 Build robust API integrations faster with `kayto_ts`.
+`kayto_ts` is a type-safe HTTP client that works in pair with `kayto` 🦀 (Rust).
+
+`kayto` generates `schema.ts` from your OpenAPI spec, and `kayto_ts` uses that schema to provide strongly-typed requests, responses, and hooks across any TypeScript platform: browser, Bun, Node.js, Deno, and more.
 
 - 🔒 End-to-end type safety for `method + path + params + body + response`
 - ⚡ Zero-boilerplate HTTP client usage with generated schema types
@@ -38,7 +40,7 @@ kayto --lang ts --input "https://example.com/openapi.json" --output "generated/s
 If you generate one schema file per microservice, keep clients centralized in one place.
 
 ```ts
-import { clientApi, type EndpointsMap } from "kayto_ts";
+import { clientApi } from "kayto_ts";
 import type { Endpoints as AccountsEndpoints } from "./schemas/accounts";
 import type { Endpoints as BillingEndpoints } from "./schemas/billing";
 import type { Endpoints as NotificationsEndpoints } from "./schemas/notifications";
@@ -49,7 +51,7 @@ const SERVICE_URLS = {
   notifications: "https://notifications.example.com",
 } as const;
 
-function createServiceClient<TEndpoints extends EndpointsMap>(baseUrl: string) {
+function createServiceClient<TEndpoints>(baseUrl: string) {
   return clientApi<TEndpoints>({
     baseUrl,
     onRequest: ({ init }) => {

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-import { type Api, type ClientConfig, type EndpointsMap } from "./types.js";
-export type { Api, ClientConfig, ClientError, ClientHooks, EndpointsMap, EndpointOf, EndpointResponseMap, EndpointResult, FetchResult, RequestInput, RequestOptions, } from "./types.js";
-export declare function clientApi<Endpoints extends EndpointsMap>(config?: ClientConfig): Api<Endpoints>;
+import { type Api, type ClientConfig, type PartialEndpointsMap } from "./types.js";
+export type { Api, ClientConfig, ClientError, ClientHooks, EndpointsMap, PartialEndpointsMap, HttpMethod, EndpointOf, EndpointResponseMap, EndpointResult, FetchResult, RequestInput, RequestOptions, } from "./types.js";
+export declare function clientApi<Endpoints extends PartialEndpointsMap>(config?: ClientConfig): Api<Endpoints>;

package/dist/index.js

@@ -107,10 +107,10 @@ export function clientApi(config = {}) {
         return { ok: true, responses, response };
     };
     return {
-        get: (path, ...args) => request("get", path, args[0]),
-        post: (path, ...args) => request("post", path, args[0]),
-        put: (path, ...args) => request("put", path, args[0]),
-        patch: (path, ...args) => request("patch", path, args[0]),
-        delete: (path, ...args) => request("delete", path, args[0]),
+        get: ((path, ...args) => request("get", path, args[0])),
+        post: ((path, ...args) => request("post", path, args[0])),
+        put: ((path, ...args) => request("put", path, args[0])),
+        patch: ((path, ...args) => request("patch", path, args[0])),
+        delete: ((path, ...args) => request("delete", path, args[0])),
     };
 }

package/dist/types.d.ts

@@ -1,11 +1,11 @@
-export type EndpointsMap = {
-    get: Record<PropertyKey, unknown>;
-    post: Record<PropertyKey, unknown>;
-    put: Record<PropertyKey, unknown>;
-    patch: Record<PropertyKey, unknown>;
-    delete: Record<PropertyKey, unknown>;
+export type HttpMethod = "get" | "post" | "put" | "patch" | "delete";
+export type EndpointsMap = Record<HttpMethod, Record<PropertyKey, unknown>>;
+export type PartialEndpointsMap = Partial<EndpointsMap>;
+export type EnsureRecord<T> = T extends Record<PropertyKey, unknown> ? T : Record<never, never>;
+export type NormalizeEndpoints<Endpoints extends PartialEndpointsMap> = {
+    [Method in HttpMethod]: EnsureRecord<Endpoints[Method]>;
 };
-export type EndpointOf<Endpoints extends EndpointsMap, Method extends keyof EndpointsMap, Path extends keyof EndpointsMap[Method]> = Endpoints[Method][Path];
+export type EndpointOf<Endpoints extends PartialEndpointsMap, Method extends HttpMethod, Path extends keyof NormalizeEndpoints<Endpoints>[Method]> = NormalizeEndpoints<Endpoints>[Method][Path];
 export type EndpointParams<E> = E extends {
     params: infer P;
 } ? P : never;
@@ -54,22 +54,22 @@ export type RequestInput<E> = RequestOptions & ([EndpointParams<E>] extends [nev
     body: EndpointBody<E>;
 });
 export type RequestArgs<E> = [EndpointBody<E>] extends [never] ? [input?: RequestInput<E>] : [input: RequestInput<E>];
-export type Api<Endpoints extends EndpointsMap> = {
-    [Method in keyof EndpointsMap]: <Path extends Extract<keyof Endpoints[Method], string>>(path: Path, ...args: RequestArgs<EndpointOf<Endpoints, Method, Path>>) => Promise<FetchResult<EndpointOf<Endpoints, Method, Path>>>;
+export type Api<Endpoints extends PartialEndpointsMap> = {
+    [Method in HttpMethod]: <Path extends Extract<keyof NormalizeEndpoints<Endpoints>[Method], string>>(path: Path, ...args: RequestArgs<EndpointOf<Endpoints, Method, Path>>) => Promise<FetchResult<EndpointOf<Endpoints, Method, Path>>>;
 };
 export type RequestHookContext = {
-    method: keyof EndpointsMap;
+    method: HttpMethod;
     path: string;
     init: RequestInit;
 };
 export type ResponseHookContext = {
-    method: keyof EndpointsMap;
+    method: HttpMethod;
     path: string;
     response: Response;
     durationMs: number;
 };
 export type ResponseInterceptorContext = {
-    method: keyof EndpointsMap;
+    method: HttpMethod;
     path: string;
     response: Response;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kayto_ts",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "Type-safe HTTP client for working with kayto-generated endpoint schemas.",
   "repository": {
     "type": "git",