MonoriseDynamoDB Single-Table Toolkit
Type-safe, event-driven data layer for applications built on DynamoDB. Define schemas, get APIs, relationships, and processors automatically.
Skip to content
Full-stack in minutes
Define your entities, deploy with SST, and query from React — all type-safe, all from one package.
ts
export default $config({
app(input) {
return { name: 'my-app', home: 'aws' };
},
async run() {
const { monorise } = await import('monorise/sst');
const { api } = new monorise.module.Core('core', {
allowOrigins: ['http://localhost:3000'],
});
new sst.aws.Nextjs('Web', {
link: [api],
});
},
});ts
import { createEntityConfig } from 'monorise/base';
import { z } from 'zod/v4';
const baseSchema = z.object({
name: z.string(),
email: z.string().email(),
role: z.enum(['admin', 'member']),
}).partial();
const createSchema = z.object({
name: z.string().min(1),
email: z.string().email(),
});
export default createEntityConfig({
name: 'member',
displayName: 'Member',
baseSchema,
createSchema,
searchableFields: ['name', 'email'],
uniqueFields: ['email'],
tags: [
{
name: 'role',
processor: (entity) => [{ group: entity.data.role }],
},
],
});tsx
import { useEntities, createEntity } from 'monorise/react';
import { Entity } from '#/monorise';
export default function MembersPage() {
const { entities: members, searchField, isLoading } = useEntities(Entity.MEMBER);
const handleCreate = async () => {
await createEntity(Entity.MEMBER, {
name: 'Alice',
email: 'alice@example.com',
});
};
return (
<div>
<input {...searchField} placeholder="Search members..." />
<button onClick={handleCreate}>Add Member</button>
{members?.map((m) => (
<div key={m.entityId}>{m.data.name} — {m.data.email}</div>
))}
</div>
);
}That's it — API, DynamoDB, EventBridge, processors, and a type-safe frontend. Get started →
Why Monorise?
Single-Table DynamoDB
One table, O(1) performance for every query. Monorise handles denormalization and replication automatically.
Zero Schema Drift
One Zod config drives your entire stack. Edit → save → types regenerate instantly. DB, backend, and frontend stay perfectly in sync.
Ship in Hours, Not Weeks
From git init to production API in minutes. No migration scripts. No access pattern spreadsheets. No hand-rolled GSI headaches.
Relational Access Patterns
Entity, Mutual, and Tag concepts give you relational-style queries on DynamoDB without complex hand-written expressions.
Full-Stack SDK
Backend API (Hono), React hooks with caching, SST v4 infrastructure module — one package covers the entire stack.
Seamless Dev Workflow
Run npx sst dev and everything just works — handlers, types, and Lambda entry points are auto-generated as you edit entity configs.
Token-Efficient Development
No re-implementing CRUD boilerplate or DynamoDB patterns. One config gives you API, types, and processors — less code, fewer tokens, faster shipping.