Build enterprise applications in TypeScript. Share business logic across HTTP APIs, command-line tools and message workers, with explicit module boundaries and dependency checks at startup.
deno add jsr:@chojs/webimport { ChoWeb, Controller, Get, Module } from "@chojs/web";
import { serve } from "@chojs/web/serve";
@Controller()
class HelloController {
@Get("")
hello() {
return { message: "Hello, world!" };
}
}
@Module({ controllers: [HelloController] })
class App {}
const app = await ChoWeb.create(App);
await serve(app.handler, { port: 3000 });localhost:3000/200 OK{ "message": "Hello, world!" }One file. A real application. Your choice of runtime.
At home on
your runtime.
Modules, providers, controllers. The same three building blocks for an API, a CLI or a message consumer. Just change the decorator on the method.
How CHO is organized →import {
ChoWeb,
type ChoWebContext,
Controller,
Get,
Injectable,
Module,
} from "@chojs/web";
@Injectable()
class UserStore {
find(id: string) {
return { id, name: "Ada" };
}
}
@Controller({ route: "users", dependencies: [UserStore] })
class UsersController {
constructor(readonly store: UserStore) {}
@Get(":id") // GET /users/42
get(ctx: ChoWebContext) {
return this.store.find(ctx.params.id!); // sent as JSON
}
}
@Module({ providers: [UserStore], controllers: [UsersController] })
class App {}
const app = await ChoWeb.create(App);import {
Action,
ChoCommand,
type ChoCommandContext,
Controller,
Help,
Module,
} from "@chojs/command";
@Controller()
class Greeter {
@Help("Say hello")
@Action("hello", { string: ["name"] })
hello(ctx: ChoCommandContext) {
console.log(`Hello, ${ctx.args.name ?? "world"}!`);
}
}
@Module({ controllers: [Greeter] })
class App {}
const app = ChoCommand.create(App, { name: "greet" });
const code = await app.run(Deno.args); // the exit codeimport {
ChoMessage,
Args, Value,
Controller,
Module,
Subscribe,
} from "@chojs/message";
@Controller({ topic: "orders" })
class OrdersController {
@Subscribe("created") // the topic orders.created
@Args(Value<string>("id"))
created(id: string) {
console.log("Received order", id);
}
}
@Module({ controllers: [OrdersController] })
class App {}
const app = await ChoMessage.create(App);
await app.handle("orders.created", { key: "42", value: '{"id":"42"}' });
await app.close();CHO tests HTTP applications on four runtimes: Deno, Node.js, Bun and Cloudflare Workers. A dedicated CI job runs the Workers tests in workerd, including requests that use bindings and background tasks.
URLPattern.serve(app.handler) in a server process or export fetch: app.handler on Workers.CHO runs with TC39 decorators, and with the legacy ones of TypeScript and Bun. Dependencies are declared, not guessed from emitted types, and the compiler checks them against the constructor.
reflect-metadata, no emitDecoratorMetadata.const PORT = token<number>("PORT");
@Injectable([Logger, PORT]) // in constructor order
class Server {
constructor(logger: Logger, port: number) {}
}
@Injectable([PORT, Logger])
class Broken {
constructor(logger: Logger, port: number) {}
}Compile error: the constructor of Broken wants (Logger, number).
The whole module graph is validated and linked once, when the application is created. A missing provider, a circular import or a duplicate route never waits for the first request.
await a connection before its value is ready.onInit hook to write.close() releases the instances in reverse order.$ deno run --allow-net main.ts Error: Cannot resolve Database (argument #0) of UserStore in module UsersModule. Provide it there or import a module that exports it. # fixed, and run again $ deno run --allow-net main.ts Error: Duplicate route "GET /users/:id": declared by UsersController.get and AdminController.find # fixed $ deno run --allow-net main.ts listening on http://localhost:3000
Test handlers in memory, validate incoming data and resume event processing after downtime with a durable consumer.
On a module, a controller or one method. As a function, or as a class the injector creates, with dependencies of its own.
app.handler(new Request(…))A request is a function call, and so is a message. Replace any provider with a fake, anywhere in the graph, with overrides.
Declare what a handler reads from the request. Validate and transform inputs with Standard Schema libraries such as Zod, Valibot or ArkType.
@SseA handler is an async generator. Each yield is an event, and a client that leaves ends the loop.
--help is generated from the flags each command declares. run() returns the exit code.
A durable consumer picks up stored events, retries failed deliveries and can send exhausted messages to a dead-letter stream.
ChoMessage.from(web.injector)One database pool, one cache, for the requests and for the messages of the same process.
Apache KafkaRun the same consumer on Node.js, Deno or Bun. Broker tests cover offset commits, retries and partition ordering.
Start with a single file. Grow into modules. Take it to the runtime that works for you.
deno add jsr:@chojs/webnpx jsr add @chojs/webbunx jsr add @chojs/web