Define models once. Write intent as JSON. Get parameterized SQL and inferred TypeScript types — no magic between the object and the query. Define modelos una vez. Expresa intención en JSON. Obtén SQL parametrizado y tipos TypeScript inferidos — sin magia entre el objeto y la consulta.
pnpm dlx jsorm init How it works Cómo funciona
No hidden layers. JSON intent flows through a structured AST to deterministic SQL. Sin capas ocultas. La intención JSON fluye por un AST estructurado hasta SQL determinista.
Declare fields once with typed builders. Types and runtime metadata share the same source. Declara campos una vez con builders tipados. Tipos y metadatos en tiempo de ejecución comparten la misma fuente.
const User = defineModel('users', {
id: t.number().primary(),
name: t.string(),
role: t.belongsTo(Role),
});Describe intent with plain objects. No chains, no decorators, no generated strings. Describe la intención con objetos simples. Sin chains, sin decoradores, sin strings generados.
const users = await db.get(User, {
select: { name: true, role: { name: true } },
where: { active: true },
orderBy: [{ name: 'asc' }],
});The ORM converts JSON to AST, emits parameterized SQL, and maps rows back to inferred types. El ORM convierte JSON a AST, emite SQL parametrizado y mapea las filas a tipos inferidos.
// users is typed as:
// Array<{ name: string; role: { name: string } }>
// — inferred directly from defineModel()Core features Características core
Every feature is built around a single source of truth: your model definition and the structured AST derived from it. Cada característica está construida alrededor de una única fuente de verdad: tu definición de modelo y el AST estructurado derivado de ella.
Describe reads and writes with plain objects instead of opaque chain builders. Describe lecturas y escrituras con objetos simples en lugar de builders opacos.
await db.get(User, {
select: { id: true, role: { name: true } },
where: { active: true },
});Define schemas once and infer records plus input types directly from models. Define esquemas una vez e infiere registros y tipos de entrada directamente desde los modelos.
const User = defineModel('users', {
id: t.number().primary(),
name: t.string(),
role: t.belongsTo(Role),
});Use belongsTo, hasOne, hasMany, and manyToMany with predictable SQL behavior. Usa belongsTo, hasOne, hasMany y manyToMany con comportamiento SQL predecible.
const Post = defineModel('posts', {
author: t.belongsTo(User),
tags: t.manyToMany(Tag),
});Orchestrate PostgreSQL, MySQL, and SQLite connections from one typed entry point. Orquesta conexiones PostgreSQL, MySQL y SQLite desde un punto de entrada tipado.
const db = connectionDB({
databases: {
main: pgAdapter({ connectionString }),
cache: sqliteAdapter({ file: ':memory:' }),
},
});Keep full SQL power available through executeSql() without abandoning the JSON API. Mantén toda la potencia de SQL disponible con executeSql() sin abandonar la API JSON.
await db.executeSql(
'SELECT COUNT(*) AS count FROM users WHERE active = ?',
[true],
);Connect to an existing database immediately or opt into migration runtime and CLI. Conéctate a una base existente de inmediato u opta por runtime y CLI de migraciones.
const source = defineConnectionSource({
adapter: pgAdapter({ connectionString }),
});Code examples Ejemplos de código
Use jsorm for schemas, nested reads, relation mutations, and raw SQL — all without losing type safety. Usa jsorm para esquemas, lecturas anidadas, mutaciones de relaciones y SQL raw — sin perder seguridad de tipos.
const Role = defineModel('roles', {
id: t.number().primary(),
name: t.string().unique(),
});
const User = defineModel('users', {
id: t.number().primary(),
name: t.string(),
role: t.belongsTo(Role),
});await db.insert(User, {
name: 'Alice',
role: { connect: 1 },
profile: {
create: { bio: 'Builder' },
},
});const rows = await db.get(User, {
select: {
id: true,
name: true,
role: { name: true },
},
where: {
role: {
name: { eq: 'admin' },
},
},
});Why jsorm Por qué jsorm
Most ORMs optimize for magic shortcuts. jsorm optimizes for explicitness — so you always know the SQL your code produces. La mayoría de los ORMs optimizan para atajos mágicos. jsorm optimiza para la explicitud — para que siempre sepas el SQL que produce tu código.
Query style Estilo de consulta
jsorm
JSON-like objects backed by a structured AST Objetos tipo JSON respaldados por un AST estructurado
Traditional Tradicional
Chains, decorators, or handwritten query builders Chains, decoradores o query builders escritos a mano
Typing Tipado
jsorm
Inference from defineModel() as single source of truth Inferencia desde defineModel() como única fuente de verdad
Traditional Tradicional
Manual interfaces or duplicated types are common Interfaces manuales o tipos duplicados son comunes
SQL visibility Visibilidad de SQL
jsorm
AST and executeSql() keep SQL behavior explicit El AST y executeSql() mantienen el comportamiento SQL explícito
Traditional Tradicional
Magic layers can hide generated SQL details Capas mágicas pueden ocultar detalles del SQL generado
Ecosystem Ecosistema
Install only what you need. Keep the core package lightweight while adapters wrap official drivers. Instala solo lo que necesitas. Mantén el paquete core liviano mientras los adaptadores envuelven drivers oficiales.
Core ORM, model system, query AST, migrations, CLI, and adapter contracts. ORM core, sistema de modelos, AST de consultas, migraciones, CLI y contratos de adaptadores.
PostgreSQL adapter built around official pg driver patterns. Adaptador PostgreSQL construido sobre los patrones del driver oficial pg.
SQLite adapter for lightweight apps, local tools, and tests. Adaptador SQLite para apps livianas, herramientas locales y pruebas.
MySQL adapter for production services and analytics workloads. Adaptador MySQL para servicios productivos y cargas analíticas.
Start building Comienza a construir
Model schemas, connect adapters, run migrations, and build typed queries in minutes. Read the docs to get started. Modela esquemas, conecta adaptadores, ejecuta migraciones y construye consultas tipadas en minutos. Lee la documentación para empezar.