KoalaTs for backend teams
TypeScript services your team can read the same way
KoalaTs gives Node teams a function-first backend framework with visible service wiring, explicit request handling, and framework utilities for the work every service has to repeat.
Function-first flow
From application setup to HTTP response
Config
Declare the service entry points before requests run.
Pipeline
Put validation and security where reviewers can see it.
Handler
Handle request data and response data directly.
Utilities
Reach for focused helpers without hiding the flow.
const app = create({
routes,
globalMiddleware,
staticFiles,
});Team friction
Backend code gets harder to review when every service invents its own shape
Teams lose time when setup is scattered, middleware order is implicit, and contributors have to rediscover the local service pattern before they can make a safe change.
The framework should make the common path visible.
KoalaTs is built for teams that want backend conventions to be easy to inspect in code review, not hidden behind local patterns that differ from project to project.
- Service setup becomes hard to trust when routes, middleware, assets, and events are wired in different places.
- Request behavior is harder to review when validation and security live outside the path a request actually takes.
- Shared helpers drift when each service chooses its own approach to testing, passwords, serialization, or request context.
- New contributors move slower when they must learn a local framework shape before changing backend behavior.
Framework model
A small set of explicit pieces, composed in order
KoalaTs keeps the service model practical: application configuration defines the entry points, routes and middleware stay as functions, HTTP state stays visible at the boundary, and utilities solve specific backend jobs.
- Application configuration declares routes, global middleware, static files, and event subscribers in one place.
- Routes, middleware, validators, and subscribers are functions the team can compose and review directly.
- Request data, response data, and validation rules stay explicit at the HTTP boundary.
- Focused utilities support security, testing, serialization, passwords, static files, and request-scoped state.
Start with the application
Use create(...) to declare the service entry points before request handling begins.
Build the request path
Compose routes, middleware, validators, and subscribers as plain pieces in the order the service needs.
Add focused support
Use security, testing, password, serializer, static file, and request-scope utilities without moving behavior out of sight.
Capabilities
The framework surface teams usually need around HTTP work
Application configuration
Declare routes, global middleware, static files, and event subscribers from the application setup.
Function-first routing
Define HTTP methods and paths as route functions that keep backend entry points easy to scan.
Request and response primitives
Work with body, query, parameters, headers, status, response body, and response headers directly.
Validation toolkit
Use built-in constraints, custom validators, flattened violations, and reusable validation middleware.
Security utilities
Apply firewall middleware for authenticated routes and use password hashing utilities for credential workflows.
Static files and assets
Serve public assets from configurable static file settings when a service needs to expose files directly.
Testing support
Create HTTP test agents from application configuration, including authenticated request scenarios.
Serialization and normalization
Normalize common response data structures with framework utilities for arrays, records, dates, and null values.
Request-scoped context
Propagate per-request data across async work when handlers, middleware, subscribers, and shared utilities need the same context.
Examples
Start from the application, then follow the functions
The examples follow the same path a reviewer follows: application setup, route behavior, then validation middleware.
import {create} from '@koala-ts/framework';
import {statusRoute} from './routes';
const app = create({
routes: [statusRoute],
});
app.listen(3000);
Getting Started
Evaluate the model, then build from it
Run the quick start
Generate a new application with `npx @koala-ts/cli create my-app` and inspect the default structure.
Read the framework guide
Review how configuration, routing, validation, request, and response concepts fit together.
Apply it to a service
Register a route, add validation or middleware where needed, and keep the change easy to review.
Try the service shape or read the model first
Use the quick start to create a running service, or read the framework guide before you bring the pattern to a team codebase.