TypeScript
TypeScript is Putnami's most complete application surface: React SSR, API routes, forms, auth, data, storage, events, health, telemetry, and build tooling in one workspace-native stack.
Use it when you want a full-stack app or API where frontend, backend, data access, and runtime behavior share one set of conventions.
Choose your path
| Goal | Start here | Then read |
|---|---|---|
| Create your first TypeScript project | Getting Started | How To / Guides, Extension phases, Overview |
| Build a full-stack web app | Web | React routing, Forms & actions, Static files |
| Build an API service | API | HTTP & middleware, Errors & responses |
| Add users and sessions | Auth | Sessions, Configuration |
| Store application data | Persistence | Document storage, Storage |
| Add async and realtime behavior | Events | WebSockets & streaming, Caching |
| Make it production-readable | Health checks | Telemetry, Logging, Platform endpoints |
The application model
Putnami TypeScript apps are composed from small runtime plugins:
- Application owns lifecycle and startup.
- Modules group related capabilities such as auth, API, or data.
- Plugins register servers, routes, providers, hooks, health checks, and generated assets.
That model lets a small app stay small while still having a clear upgrade path to a larger service:
application()
.use(http())
.use(api())
.use(react())
.use(sql());Capability map
| Capability | Read | Why it matters |
|---|---|---|
| Toolchain | Extension phases | Detection, dependencies, generate, build, test, lint, serve, publish, Docker, and caching |
| Composition | Overview, Plugins & lifecycle | How apps are assembled and started |
| Runtime wiring | Dependency injection, Configuration | Explicit dependencies, typed config, request scopes |
| Contracts | Schema, Proto & gRPC, Smart client | Typed boundaries between services and clients |
| Operations | Testing, Health checks, Telemetry | Confidence before deploy and signals after deploy |
Recommended first hour
- Start with Getting Started to create a web app, API service, or library.
- Use How To / Guides for the first concrete task.
- Read Extension phases when build, test, serve, publish, or Docker behavior matters.
- Read Overview to understand the package map.
- Pick Web or API depending on your first app shape.
- Add Configuration and Dependency injection before the app grows implicit wiring.