Typed clients

DaloyJS ships two ways to call your API with full type-safety. Use whichever fits your consumer.

1. In-process typed client (zero codegen)

For TypeScript consumers in the same monorepo (tests, internal tools, Next.js server actions):

import { createInProcessClient } from "@daloyjs/core/client";
import { app } from "./app.js";

const client = createInProcessClient(app);

const r = await client.getBookById({ params: { id: "1" } });
//    ^? { status: 200; body: { id: string; title: string } }
//      | { status: 404; body: ProblemJson }

if (r.status === 200) {
  console.log(r.body.title); // string, fully typed
}

The client is keyed by operationId, returns a discriminated union of {status, body, headers}, and infers everything from the route definition itself. No build step.

2. Hey API SDK (cross-language, cross-repo, build-time)

For consumers outside the monorepo or in other languages, generate a fully typed fetch SDK with @hey-api/openapi-ts.

pnpm add -D @hey-api/openapi-ts prettier

// openapi-ts.config.ts
import { defineConfig } from "@hey-api/openapi-ts";

export default defineConfig({
  input: "./generated/openapi.json",
  output: { path: "./generated/client", postProcess: ["prettier"] },
  plugins: ["@hey-api/client-fetch", "@hey-api/typescript", "@hey-api/sdk"],
});

// package.json
"scripts": {
  "gen:openapi": "node scripts/dump-openapi.ts",
  "gen:client":  "openapi-ts",
  "gen":         "pnpm gen:openapi && pnpm gen:client"
}

pnpm gen
# writes:
#   generated/openapi.json
#   generated/client/{client.gen.ts, sdk.gen.ts, types.gen.ts, index.ts}

Using the generated SDK

import { client } from "./generated/client/client.gen.js";
import { getBookById } from "./generated/client/sdk.gen.js";

client.setConfig({ baseUrl: "https://api.example.com" });

const { data, error } = await getBookById({ path: { id: "1" } });
if (error) console.error(error);
else if (data) console.log(data.title);

Which one should I use?

Coming from ts-rest?

ts-rest is a popular contract-first library that gives you end-to-end TypeScript types without codegen by sharing a contract (initContract) between an adapter-based server (Express, Fastify, NestJS, Next.js) and a fetch client (initClient). If you like that model, DaloyJS will feel familiar, with two differences.

First, in DaloyJS the route definition is the contract, there is no separate contract object to keep in sync. The in-process createClient shown above gives the same zero-codegen, shared-types experience for same-repo TypeScript callers.

Second, ts-rest's type safety is TypeScript-only and requires the client to import the contract. DaloyJS emits a first-class OpenAPI 3.1spec and a Hey API SDK from the same routes, so consumers that can't import your types (other repos, other languages, public SDKs) are covered too. In ts-rest, OpenAPI is an optional add-on (@ts-rest/open-api). DaloyJS is also the server and runtime itself, portable across Node, Bun, Deno, Cloudflare, and Vercel, rather than a typing layer mounted on a separate framework.

Need a bigger contract to validate your generator output? Use the large fake REST demo as the stress case instead of a minimal tutorial app.