DORM makes building multi-tenant applications on Cloudflare ridiculously easy by letting you:
- Create unlimited SQLite DBs on the fly (up to 10GB each)
- Query them directly from anywhere in your worker (not just inside DOs)
- Explore and manage your data with built-in Outerbase integration
- Migrate once, everywhere with built-in JIT migration-support
Perfect for SaaS applications, user profiles, rate limiting, or any case where you need isolated data stores that are lightning fast at the edge.
Demo app: https://dorm.wilmake.com | Give me a like/share on X
| Feature | Vanilla DOs | DORM 🛏️ | D1 | Turso |
|---|---|---|---|---|
| Multi-tenant | ✅ Unlimited | ✅ Unlimited | ❌ One DB | Pricey |
| Query from worker | ❌ Only in DO | ✅ | ✅ | ✅ |
| Data Explorer | ❌ | ✅ Outerbase | ✅ | ✅ |
| Migrations | ❌ | ✅ | ✅ | ✅ |
| Edge Performance | Closest to user | Closest to user | Global edge | Global edge |
| Developer Experience | ❌ Verbose, complex | ✅ Clean, low verbosity | ✅ Good | Good, not CF native |
See Turso vs DORM and DORM vs D1 for a more in-depth comparison with these alternatives. Also, see the pricing comparison here
Check out the live TODO app demo showing multi-tenant capabilities.
Install dormroom as dependency...
npm i dormroom@next...or fork this repo, and use template.ts as a starting point.
Local Development:
- Install: https://github.com/outerbase/studio
- Create starbase connecting to: http://localhost:8787/db (or your port, your prefix)
Production: Use https://studio.outerbase.com
Create a separate database for each customer/organization:
const client = createClient({
doNamespace: env.MY_DO_NAMESPACE,
version: "v1",
name: `tenant:${tenantId}`, // One DB per tenant
migrations: {
1: [
/* Your sql statements to create tables or alter them. Migrations are applied just once. */
],
},
});Store user data closest to where they access it:
const client = createClient({
doNamespace: env.MY_DO_NAMESPACE,
version: "v1",
name: `user:${userId}`, // One DB per user
});Mirror tenant operations to a central database for analytics:
const client = createClient({
doNamespace: env.MY_DO_NAMESPACE,
name: `tenant:${tenantId}`,
mirrorName: "aggregate", // Mirror operations to an aggregate DB
});When creating mirrors, be wary of naming collisions and database size:
-
Unique id collisions: when you use auto-increment and unique IDs (or columns in general), you may run into the issue that the value is unique in the main DB, but not in the mirror. This is currently not handled and your mirror query will silently fail! To prevent this issue I recommend not using auto increment or random in the query, and generate unique IDs beforehand when doing a query, so the data remains the same.
-
Size: You have max 10GB. When executing a query, you can choose to use
skipMirror:trueto not perform the same query in the mirror db, to save on size for DBs with larger tables.
- Direct SQL anywhere: No need to write DO handler code - query from your worker
- Outerbase integration: Explore and manage your data with built-in tools
- JSON Schema support: Define tables using JSON Schema with automatic SQL translation
- Streaming queries: Efficient cursor implementation for large result sets
- JIT Migrations: Migrations are applied when needed, just once, right before a DO gets accessed.
- Data mirroring: Mirror operations to aggregate databases for analytics
- Low verbosity: Clean API that hides Durable Object complexity
import { jsonSchemaToSql, TableSchema } from "dormroom";
const userSchema: TableSchema = {
$id: "users",
properties: {
id: { type: "string", "x-dorm-primary-key": true },
name: { type: "string", maxLength: 100 },
email: { type: "string", "x-dorm-unique": true },
},
required: ["id", "name"],
};
const sqlStatements = jsonSchemaToSql(userSchema);// Get a cursor for working with large datasets
const cursor = client.exec<UserRecord>("SELECT * FROM users");
// Stream results without loading everything into memory
for await (const user of cursor) {
// Process each user individually
}// Access your database via REST API
const middlewareResponse = await client.middleware(request, {
prefix: "/api/db",
secret: "my-secret-key",
});- ✅ Nearly zero overhead: Thin abstraction over DO's SQLite
- ✅ Edge-localized: Data stored closest to where it's accessed
- ✅ Up to 10GB per DB: Sufficient for most application needs
- ❓ Localhost isn't easily accessible YET in https://studio.outerbase.com so you need to deploy first, use a tunnel, or run the outerbase client on localhost.
- X-OAuth Template using DORM
- Follow me on X for updates
- Original project: ORM-DO
- Inspiration/used work - The convention outerbase uses is reapplied to make the integration with outerbase work!
- Original idea for mirroring
- DORM uses a 'remote sql cursor' at its core - see repo+post here
DORM is currently in beta. API may change, but core functionality is stable.