Chowk, the example application

Every example in these docs is drawn from one application: Chowk, a small online marketplace. A chowk is a market square — the public place where a town's buying and selling happens — and this one sells the usual things a marketplace does: it lists products, takes orders, tracks stock, and ships what people buy.

Chowk exists so the docs never have to invent a snippet. It is a real, compiling Vishwakarma project, and every code sample you see is lifted from its source — so if a page shows you a command or a saga, that is exactly how it is written in an application that builds and runs.

What it models

Chowk is organized into sub-domains — one self-contained slice of the business per folder, each owning its own aggregates and operations.

A shared enterprise_kernel sub-domain holds the cross-cutting machinery every context reuses — for example, the audit trail that records notable actions.

The spine: an order's lifecycle

The one thread that runs through the whole application is what happens when someone buys something. It touches three sub-domains, and the hand-off between them is the interesting part.

flowchart LR
  P["catalog<br/>Product (priced)"] -.->|"added as a line"| O
  subgraph ordering
    O["Order<br/>PENDING → PAID"] --> OL["OrderLine"]
  end
  O -->|"emits OrderPlaced"| S["fulfillment<br/>Shipment"]

A customer opens an Order (born PENDING) and adds an OrderLine for a catalog Product — Chowk does both in one transaction with a use_case saga called Checkout. Paying marks the order PAID. Placing the order also emits an OrderPlaced event, and the fulfillment sub-domain reacts to that fact by opening a Shipment — without ordering ever calling fulfillment directly. Ordering just announces what happened; fulfillment decides what to do about it.

That decoupling is not incidental. It is how the sub-domains stay independent: a fact is published in one place and consumed in another, so either side can change without reaching into the other.

Why one running example

Threading a single domain through every page does two things. It keeps the nouns familiar — once you know what an Order and an OrderLine are, every later example builds on them instead of starting over. And it keeps the docs honest: because Chowk compiles, the examples cannot quietly drift out of date, the way a hand-written snippet in a document would. When a page needs to show a new construct, the construct is added to Chowk first, compiled, and then quoted here.

The rest of this manual uses Chowk without ceremony: your first model starts from its Product, and the later pages reach for its orders, its checkout saga, and its shipment flow as each idea comes up.