yatta/client

Substitutes `:name` segments and percent-encodes each value.

Encoding per segment rather than the whole path matters: an id containing a slash would otherwise add a path segment, and a value containing `?` or `#` would truncate the URL.

Builds a client for a route table.

1const routes = defineRoutes({2  getUser: route({3    method: "get",4    path: "/users/:id",5    params: z.object({ id: z.string() }),6    response: UserSchema,7  }),8});9 10const api = createClient(routes, { baseUrl: "https://api.example.com" });11const user = await api.getUser({ params: { id: "42" } }); // typed from UserSchema

Declares a table of routes.

Also an identity function, for the same reason.

Declares one route.

An identity function, so the literal keeps its exact types — including which validators were supplied and which were omitted, which is what makes the conditional types above resolve.

Serialises a query object, dropping empty values and expanding arrays.

One route: where it goes, what it accepts, and what it returns.

Every validator is optional, because an endpoint legitimately has no body, and an optional field means the route can be declared from as little as a method and a path.

The client object: one method per route, named by its key in the table.

`R[N]` is passed straight through. Intersecting it with `RouteDef` to force resolution — the usual trick for a deferred indexed access — collapsed each field's type into `Schema & Schema | undefined`, so every query and body came back `unknown`.

Arguments accepted by one method.

Written as an intersection of conditionals rather than a mapped type over `keyof CallArgs<T>`. `keyof` applied to an unresolved conditional type is empty, so every argument vanished from the signature: the client worked at runtime while accepting nothing useful at compile time. Each part contributes its key only when the route declares that input, so passing a `body` to a route without one is an error rather than a field that is quietly dropped on the floor.

One method, inferred straight from a route definition.

Deliberately not built on : going through a named intermediate type left `R[N]` deferred inside the mapped type, so every signature stayed unresolved and the client rejected correct arguments at compile time while working fine at runtime. Inferring from the definition directly has one fewer layer to defer. Written as two overloads rather than one generic signature with a conditional return. The generic version looked equivalent and was not: TypeScript inferred the argument type from the call and never checked it against the route's schema, so a body of the wrong shape passed a clean compile and failed at runtime. Overloads check each case on its own. The second overload is what `raw: true` selects. With the validator switched off nothing is known about the result, so it is typed `unknown` — the one place the client will not claim to know a shape.

Named parameters a path declares, e.g. { id: string } for "/users/:id".

A route with its declared parts resolved to concrete types.

Options every call accepts.

Separate from the route's own arguments so a route declaring no schemas still has a working signature.